[ORC] Fix runAsMain() utility function for lli to pass arguments to JITed main

[sgraenitz]

Summary

The function missed the last item of argv.

[sgraenitz]

This was fixed with 2cdb18afda8

llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp

 namespace llvm {
 namespace orc {
 
 int runAsMain(int (*Main)(int, char *[]), ArrayRef<std::string> Args,
               Optional<StringRef> ProgramName) {
   std::vector<std::unique_ptr<char[]>> ArgVStorage;
   std::vector<char *> ArgV;
 
-  ArgVStorage.reserve(Args.size() + (ProgramName ? 1 : 0));
-  ArgV.reserve(Args.size() + 1 + (ProgramName ? 1 : 0));
+  int ArgC = Args.size() + (ProgramName ? 1 : 0);
+  ArgVStorage.reserve(ArgC);
+  ArgV.reserve(ArgC + 1);
 
   if (ProgramName) {
     ArgVStorage.push_back(std::make_unique<char[]>(ProgramName->size() + 1));
     llvm::copy(*ProgramName, &ArgVStorage.back()[0]);
     ArgVStorage.back()[ProgramName->size()] = '\0';
     ArgV.push_back(ArgVStorage.back().get());
   }
 
   for (auto &Arg : Args) {
     ArgVStorage.push_back(std::make_unique<char[]>(Arg.size() + 1));
     llvm::copy(Arg, &ArgVStorage.back()[0]);
     ArgVStorage.back()[Arg.size()] = '\0';
     ArgV.push_back(ArgVStorage.back().get());
   }
   ArgV.push_back(nullptr);
 
-  return Main(Args.size(), ArgV.data());
+  return Main(ArgC, ArgV.data());
 }
 
 CtorDtorIterator::CtorDtorIterator(const GlobalVariable *GV, bool End)
   : InitList(
       GV ? dyn_cast_or_null<ConstantArray>(GV->getInitializer()) : nullptr),
     I((InitList && End) ? InitList->getNumOperands() : 0) {
 }
 

llvm/test/ExecutionEngine/OrcLazy/runAsMain0.ll

+; RUN: lli -jit-kind=orc-lazy %s -o output input
+;
+; Test that passing no arguments is ok
+;
+define i32 @main() {
+  ret i32 0
+}

llvm/test/ExecutionEngine/OrcLazy/runAsMain2.ll

+; RUN: lli -jit-kind=orc-lazy %s -o output input | FileCheck %s
+;
+; Test that trailing arguments are passed to JITed main function,
+; if it takes two arguments.
+;
+; CHECK: {{.*}}runAsMain2.ll
+; CHECK-NEXT: -o
+; CHECK-NEXT: output
+; CHECK-NEXT: input
+;
+define i32 @main(i32 %argc, i8** nocapture readonly %argv) {
+  %1 = icmp sgt i32 %argc, 0
+  br i1 %1, label %2, label %4
+
+2:
+  %3 = zext i32 %argc to i64
+  br label %5
+
+4:
+  ret i32 0
+
+5:
+  %6 = phi i64 [ 0, %2 ], [ %10, %5 ]
+  %7 = getelementptr inbounds i8*, i8** %argv, i64 %6
+  %8 = load i8*, i8** %7
+  %9 = call i32 @puts(i8* nonnull dereferenceable(1) %8)
+  %10 = add nuw nsw i64 %6, 1
+  %11 = icmp eq i64 %10, %3
+  br i1 %11, label %4, label %5
+}
+
+declare i32 @puts(i8* nocapture readonly)

llvm/tools/lli/lli.cpp

int runOrcLazyJIT(const char *ProgName) {
   }
 
   // Add the objects.
   for (auto &ObjPath : ExtraObjects) {
     auto Obj = ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(ObjPath)));
     ExitOnErr(J->addObjectFile(std::move(Obj)));
   }
 
-  // Generate a argument string.
-  std::vector<std::string> Args;
-  Args.push_back(InputFile);
-  for (auto &Arg : InputArgv)
-    Args.push_back(Arg);
-
   // Run any static constructors.
   ExitOnErr(J->runConstructors());
 
   // Run any -thread-entry points.
   std::vector<std::thread> AltEntryThreads;
   for (auto &ThreadEntryPoint : ThreadEntryPoints) {
     auto EntryPointSym = ExitOnErr(J->lookup(ThreadEntryPoint));
     typedef void (*EntryPointPtr)();
     auto EntryPoint =
       reinterpret_cast<EntryPointPtr>(static_cast<uintptr_t>(EntryPointSym.getAddress()));
     AltEntryThreads.push_back(std::thread([EntryPoint]() { EntryPoint(); }));
   }
 
   // Run main.
   auto MainSym = ExitOnErr(J->lookup("main"));
 
   typedef int (*MainFnPtr)(int, char *[]);
   auto Result = orc::runAsMain(
-      jitTargetAddressToFunction<MainFnPtr>(MainSym.getAddress()), Args,
-      StringRef("lli"));
+      jitTargetAddressToFunction<MainFnPtr>(MainSym.getAddress()), InputArgv,
+      StringRef(InputFile));
 
   // Wait for -entry-point threads.
   for (auto &AltEntryThread : AltEntryThreads)
     AltEntryThread.join();
 
   // Run destructors.
   ExitOnErr(J->runDestructors());
   CXXRuntimeOverrides.runDestructors();