fix issue that alias 0 instrution as program return values

src/eliminate_contiguous.cpp

@@ -39,6 +39,13 @@ static bool try_compute_shape(instruction_ref ins,
             return false;
         }
 
+        if (std::any_of(outputs.begin(), outputs.end(), [](auto o) {
+            return o->name() == "@return";
+        }))
+        {
+            return false;
+        }
+
         for(auto output : outputs)
         {
             auto args = output->inputs();

src/module.cpp

@@ -627,8 +627,9 @@ std::unordered_map<instruction_ref, std::string> module::print(
             var_name = this->name();
             var_name.append((this->name().empty() ? "@" : ":@"));
             var_name.append(std::to_string(count));
-            count++;
         }
+        // make instruction index to be the line num in the printed module
+        count++;
         names.emplace(ins, var_name);
 
         print_func(ins, names);

src/program.cpp

@@ -168,7 +168,7 @@ void program::compile(const target& t, compile_options options)
         {
             auto index = std::distance(mod->begin(), dangling);
             MIGRAPHX_THROW("Dangling reference in module " + mod->name() + " from instruction " +
-                           std::to_string(index));
+                           std::to_string(index) + ", (" + dangling->name() + ")");
         }
         mod->finalize(this->impl->ctx);
     }

src/targets/gpu/lowering.cpp

@@ -81,15 +81,20 @@ struct miopen_apply
         if(this->last->name() == "@return")
         {
             const auto& prog_outputs = last->inputs();
-            std::vector<instruction_ref> outputs_alias(prog_outputs.size());
+            std::vector<instruction_ref> outputs(prog_outputs.size());
 
             std::transform(prog_outputs.begin(),
                            prog_outputs.end(),
-                           outputs_alias.begin(),
-                           [](const auto& i) { return instruction::get_output_alias(i); });
+                           outputs.begin(),
+                           [](const auto& i) {
+                               auto alias_ins = instruction::get_output_alias(i);
+                               auto alias_s = alias_ins->get_shape();
+                               return (alias_s.type() == shape::tuple_type or alias_s.elements() != i->get_shape().elements()) ? i : alias_ins;
+                           }
+            );
 
             std::size_t index = 0;
-            for(auto ins : outputs_alias)
+            for(auto ins : outputs)
             {
                 prog_output_names[ins] = mod->name() + ":#output_" + std::to_string(index++);
             }
@@ -265,9 +270,27 @@ struct miopen_apply
         }
 
         auto ins_alias = instruction::get_output_alias(ins);
-        if(last->name() == "@return" and tag.empty() and prog_output_names.count(ins_alias) > 0)
+        if(last->name() == "@return" and tag.empty())
         {
-            return mod->add_parameter(prog_output_names[ins_alias], s);
+            
+            auto alias_s = ins_alias->get_shape();
+            if(alias_s.type() == shape::tuple_type or alias_s.elements() != ins->get_shape().elements())
+            {
+                if(prog_output_names.count(ins) > 0)
+                {
+                    auto out_ins = mod->add_parameter(prog_output_names[ins], s);
+                    mod->insert_instruction(std::next(ins), make_op("contiguous"), ins, out_ins);
+                    mod->replace_instruction(ins, out_ins);
+                    return out_ins;
+                }
+            }
+            else
+            {
+                if(prog_output_names.count(ins_alias) > 0)
+                {
+                    return mod->add_parameter(prog_output_names[ins_alias], s);
+                }
+            }
         }
         else if(ins == last and tag.empty())
         {