ASSERT_TRUE(module);

  std::vector<std::pair<std::string, int>> func_and_index;
  ForEachArgConsumedByFallback(
      module.get(),
      [&func_and_index](llvm::StringRef func_name, int arg_index) {
        func_and_index.push_back({func_name.str(), arg_index});
      });

  ASSERT_EQ(func_and_index.size(), 1);
  EXPECT_EQ(func_and_index[0].first, "test");
  EXPECT_EQ(func_and_index[0].second, 2);
}

}  // namespace

  unsigned num_arguments = main_fn.getNumArguments();
  for (unsigned arg_index = 0; arg_index < num_arguments; ++arg_index) {
    if (auto aliasing_output = main_fn.getArgAttrOfType<mlir::IntegerAttr>(
            arg_index, kAliasingAttr))
      output_to_input_alias[aliasing_output.getInt()] = arg_index;
  }

  if (output_to_input_alias.empty()) return absl::OkStatus();

		// GODEBUG directly.
		// TODO(moehrmann): remove when general goenvs() can be called before cpuinit()
		n := int32(0)
		for argv_index(argv, argc+1+n) != nil {
			n++
		}

		for i := int32(0); i < n; i++ {
			p := argv_index(argv, argc+1+i)
			s := unsafe.String(p, findnull(p))

			if stringslite.HasPrefix(s, prefix) {
				env = gostring(p)[len(prefix):]
				break
			}
		}

        result.addStatement("boolean $L = true", varargMatched);
        result.beginControlFlow("for (int argIndex = $1L; argIndex < invocation.getArgsCount(); argIndex++)", paramIndex);

        CodeBlock nextArg = CodeBlock.of("nextArg");
        result.addStatement("Object $L = invocation.getArgument(argIndex)", nextArg);
        result.beginControlFlow("if ($1L == null || $1L instanceof $2T)", nextArg, entryParamType);

		sep = ", "
		buf.WriteString(text)
	}
	return buf.String()
}

func gnuArg(inst *Inst, argIndex int, arg Arg) string {
	switch inst.Op &^ 15 {
	case LDRD_EQ, LDREXD_EQ, STRD_EQ:
		if argIndex == 1 {
			// second argument in consecutive pair not printed
			return ""
		}
	case STREXD_EQ:
		if argIndex == 2 {
			// second argument in consecutive pair not printed
			return ""
		}
	}

    if (index < 0) {
      return emitOpError() << "variable_arg_indices must be positive";
    }

    if (index <= prev_index) {
      return emitOpError()
             << "variable_arg_indices must be sorted in ascending order";
    }
    prev_index = index;
  }

  return mlir::success();
}

}  // namespace TF
}  // namespace mlir

// A global tensor is bound to arguments of multiple funcs.
// This struct tracks which funcs (and which argument to that func) the global
// tensor is bound to.
struct GlobalTensorUse {
  mutable func::FuncOp func;
  size_t arg_index;
};

using GlobalTensorUsesMap =
    std::map<GlobalTensorOp, std::vector<GlobalTensorUse>>;

bool IsImmutable(GlobalTensorOp global_tensor,
                 ArrayRef<GlobalTensorUse> global_tensor_uses,

        result.addStatement("boolean $L = true", varargMatched);
        result.beginControlFlow("for (int argIndex = $1L; argIndex < argumentClasses.length; argIndex++)", paramIndex);
        CodeBlock nextArg = CodeBlock.of("nextArg");
        result.addStatement("Class<?> $L = argumentClasses[argIndex]", nextArg);
        result.beginControlFlow("if ($2L != null && !$1T.class.isAssignableFrom($2L))", entryParamType, nextArg);

// of inst, it's ok to modify inst.Args here.
func plan9Arg(inst *Inst, argIndex int, pc uint64, arg Arg, symname func(uint64) (string, uint64)) string {
	// special cases for load/store instructions
	if _, ok := arg.(Offset); ok {
		if argIndex+1 == len(inst.Args) || inst.Args[argIndex+1] == nil {
			panic(fmt.Errorf("wrong table: offset not followed by register"))
		}
	}

                        Type[] argumentTypes = Type.getArgumentTypes(methodData.descriptor);
                        for (int argIndex = 1; argIndex <= argumentTypes.length; ++argIndex) {
                            visitVarInsn(argumentTypes[argIndex - 1].getOpcode(Opcodes.ILOAD), argIndex);
                        }
                        _INVOKESPECIAL(clazz.className, methodNameToVisit, methodData.descriptor, false);