Split clone value and instruction in the echo C API test

[deadalnix]

Summary

This is a bit of refactoring required to be able to generate instruction in forward basic block. This, for instance, is a requirement for phi in loops.

[mehdi_amini]

My vote is to not go through pre-commit review for NFC changes that don't touch a Core API, please proceed with post-commit review.

[deadalnix]

Ok, after discussion on IRC, this doesn't need review, unless touching the C API itself.

tools/llvm-c-test/echo.cpp

switch (Kind) {
     default:
       break;
   }
 
   fprintf(stderr, "%d is not a supported typekind\n", Kind);
   exit(-1);
 }
 
-static LLVMValueRef clone_literal(LLVMValueRef Src, LLVMContextRef Ctx) {
-  LLVMTypeRef Ty = clone_type(LLVMTypeOf(Src), Ctx);
-
-  LLVMTypeKind Kind = LLVMGetTypeKind(Ty);
-  switch (Kind) {
-    case LLVMIntegerTypeKind:
-      return LLVMConstInt(Ty, LLVMConstIntGetZExtValue(Src), false);
-    default:
-      break;
-  }
-
-  fprintf(stderr, "%d is not a supported constant typekind\n", Kind);
-  exit(-1);
-}
-
-static LLVMModuleRef get_module(LLVMBuilderRef Builder) {
-  LLVMBasicBlockRef BB = LLVMGetInsertBlock(Builder);
-  LLVMValueRef Fn = LLVMGetBasicBlockParent(BB);
-  return LLVMGetGlobalParent(Fn);
-}
-
 static ValueMap clone_params(LLVMValueRef Src, LLVMValueRef Dst);
 
 struct FunCloner {
   LLVMValueRef Fun;
+  LLVMModuleRef M;
+  LLVMContextRef Ctx;
 
   ValueMap VMap;
   BasicBlockMap BBMap;
 
   FunCloner(LLVMValueRef Src, LLVMValueRef Dst)
-    : Fun(Dst), VMap(clone_params(Src, Dst)) {}
+    : Fun(Dst), M(LLVMGetGlobalParent(Fun)), Ctx(LLVMGetModuleContext(M)),
+      VMap(clone_params(Src, Dst)) {}
 
   // Try to clone everything in the llvm::Value hierarchy.
-  LLVMValueRef CloneValue(LLVMValueRef Src, LLVMBuilderRef Builder) {
+  LLVMValueRef CloneValue(LLVMValueRef Src) {
     const char *Name = LLVMGetValueName(Src);
 
     // First, the value may be constant.
     if (LLVMIsAConstant(Src)) {
-      LLVMModuleRef M = get_module(Builder);
-
       // Maybe it is a symbol
       if (LLVMIsAGlobalValue(Src)) {
         // Try function
         LLVMValueRef Dst = LLVMGetNamedFunction(M, Name);
         if (Dst != nullptr)
           return Dst;
 
         // Try global variable
         Dst = LLVMGetNamedGlobal(M, Name);
         if (Dst != nullptr)
           return Dst;
 
         fprintf(stderr, "Could not find @%s\n", Name);
         exit(-1);
       }
 
       // Try literal
-      LLVMContextRef Ctx = LLVMGetModuleContext(M);
-      return clone_literal(Src, Ctx);
+      if (LLVMIsAConstantInt(Src)) {
+        LLVMTypeRef Ty = clone_type(LLVMTypeOf(Src), Ctx);
+        return LLVMConstInt(Ty, LLVMConstIntGetZExtValue(Src), false);
       }
 
       // Try undef
-    if (LLVMIsUndef(Src)) {
-      LLVMContextRef Ctx = LLVMGetModuleContext(get_module(Builder));
-      LLVMTypeRef Ty = clone_type(LLVMTypeOf(Src), Ctx);
-      return LLVMGetUndef(Ty);
-    }
+      if (LLVMIsUndef(Src))
+        return LLVMGetUndef(clone_type(LLVMTypeOf(Src), Ctx));
+
+      // This kind of constant is not supported.
+      report_fatal_error("Unsupported contant type");
+    }
+
+    // Function argument should always be in the map already.
+    if (LLVMIsAArgument(Src)) {
+      auto i = VMap.find(Src);
+      if (i != VMap.end())
+        return i->second;
+    }
+
+    if (LLVMIsAInstruction(Src)) {
+      auto Builder = LLVMCreateBuilderInContext(Ctx);
+      auto BB = DeclareBB(LLVMGetInstructionParent(Src));
+      LLVMPositionBuilderAtEnd(Builder, BB);
+      auto Dst = CloneInstruction(Src, Builder);
+      LLVMDisposeBuilder(Builder);
+      return Dst;
+    }
+
+    fprintf(stderr, "Could not determine the type of %s\n", Name);
+    exit(-1);
 
+  LLVMValueRef CloneInstruction(LLVMValueRef Src, LLVMBuilderRef Builder) {
+    const char *Name = LLVMGetValueName(Src);
+    if (!LLVMIsAInstruction(Src))
+      report_fatal_error("Expected an instruction");
+
     // Check if this is something we already computed.
     {
       auto i = VMap.find(Src);
       if (i != VMap.end())
         return i->second;
     }
 
     // We tried everything, it must be an instruction
     // that hasn't been generated already.
     LLVMValueRef Dst = nullptr;
 
     LLVMOpcode Op = LLVMGetInstructionOpcode(Src);
     switch(Op) {
       case LLVMRet: {
         int OpCount = LLVMGetNumOperands(Src);
         if (OpCount == 0)
           Dst = LLVMBuildRetVoid(Builder);
         else
-          Dst = LLVMBuildRet(Builder, CloneValue(LLVMGetOperand(Src, 0),
-                                                 Builder));
+          Dst = LLVMBuildRet(Builder, CloneValue(LLVMGetOperand(Src, 0)));
         break;
       }
       case LLVMBr: {
         if (!LLVMIsConditional(Src)) {
           LLVMValueRef SrcOp = LLVMGetOperand(Src, 0);
           LLVMBasicBlockRef SrcBB = LLVMValueAsBasicBlock(SrcOp);
           Dst = LLVMBuildBr(Builder, DeclareBB(SrcBB));
           break;
switch(Op) {
       case LLVMSwitch:
       case LLVMIndirectBr:
       case LLVMInvoke:
         break;
       case LLVMUnreachable:
         Dst = LLVMBuildUnreachable(Builder);
         break;
       case LLVMAdd: {
-        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0), Builder);
-        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1), Builder);
+        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
+        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
         Dst = LLVMBuildAdd(Builder, LHS, RHS, Name);
         break;
       }
       case LLVMSub: {
-        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0), Builder);
-        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1), Builder);
+        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
+        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
         Dst = LLVMBuildSub(Builder, LHS, RHS, Name);
         break;
       }
       case LLVMMul: {
-        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0), Builder);
-        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1), Builder);
+        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
+        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
         Dst = LLVMBuildMul(Builder, LHS, RHS, Name);
         break;
       }
       case LLVMUDiv: {
-        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0), Builder);
-        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1), Builder);
+        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
+        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
         Dst = LLVMBuildUDiv(Builder, LHS, RHS, Name);
         break;
       }
       case LLVMSDiv: {
-        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0), Builder);
-        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1), Builder);
+        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
+        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
         Dst = LLVMBuildSDiv(Builder, LHS, RHS, Name);
         break;
       }
       case LLVMURem: {
-        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0), Builder);
-        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1), Builder);
+        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
+        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
         Dst = LLVMBuildURem(Builder, LHS, RHS, Name);
         break;
       }
       case LLVMSRem: {
-        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0), Builder);
-        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1), Builder);
+        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
+        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
         Dst = LLVMBuildSRem(Builder, LHS, RHS, Name);
         break;
       }
       case LLVMShl: {
-        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0), Builder);
-        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1), Builder);
+        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
+        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
         Dst = LLVMBuildShl(Builder, LHS, RHS, Name);
         break;
       }
       case LLVMLShr: {
-        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0), Builder);
-        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1), Builder);
+        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
+        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
         Dst = LLVMBuildLShr(Builder, LHS, RHS, Name);
         break;
       }
       case LLVMAShr: {
-        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0), Builder);
-        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1), Builder);
+        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
+        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
         Dst = LLVMBuildAShr(Builder, LHS, RHS, Name);
         break;
       }
       case LLVMAnd: {
-        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0), Builder);
-        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1), Builder);
+        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
+        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
         Dst = LLVMBuildAnd(Builder, LHS, RHS, Name);
         break;
       }
       case LLVMOr: {
-        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0), Builder);
-        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1), Builder);
+        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
+        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
         Dst = LLVMBuildOr(Builder, LHS, RHS, Name);
         break;
       }
       case LLVMXor: {
-        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0), Builder);
-        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1), Builder);
+        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
+        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
         Dst = LLVMBuildXor(Builder, LHS, RHS, Name);
         break;
       }
       case LLVMAlloca: {
-        LLVMContextRef Ctx = LLVMGetModuleContext(get_module(Builder));
         LLVMTypeRef Ty = clone_type(LLVMGetAllocatedType(Src), Ctx);
         Dst = LLVMBuildAlloca(Builder, Ty, Name);
         break;
       }
       case LLVMICmp: {
         LLVMIntPredicate Pred = LLVMGetICmpPredicate(Src);
-        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0), Builder);
-        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1), Builder);
+        LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
+        LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
         Dst = LLVMBuildICmp(Builder, Pred, LHS, RHS, Name);
         break;
       }
       case LLVMCall: {
-        int ArgCount = LLVMGetNumOperands(Src) - 1;
         SmallVector<LLVMValueRef, 8> Args;
+        int ArgCount = LLVMGetNumOperands(Src) - 1;
         for (int i = 0; i < ArgCount; i++)
-          Args.push_back(CloneValue(LLVMGetOperand(Src, i), Builder));
-        LLVMValueRef Fn = CloneValue(LLVMGetOperand(Src, ArgCount), Builder);
+          Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
+        LLVMValueRef Fn = CloneValue(LLVMGetOperand(Src, ArgCount));
         Dst = LLVMBuildCall(Builder, Fn, Args.data(), ArgCount, Name);
         break;
       }
       default:
         break;
     }
 
     if (Dst == nullptr) {
// Check if this is something we already computed.
         return i->second;
       }
     }
 
     const char *Name = LLVMGetBasicBlockName(Src);
 
     LLVMValueRef V = LLVMBasicBlockAsValue(Src);
     if (!LLVMValueIsBasicBlock(V) || LLVMValueAsBasicBlock(V) != Src)
-      report_fatal_error("Basic block is not a basic block\n");
+      report_fatal_error("Basic block is not a basic block");
 
     const char *VName = LLVMGetValueName(V);
     if (Name != VName)
       report_fatal_error("Basic block name mismatch");
 
     LLVMBasicBlockRef BB = LLVMAppendBasicBlock(Fun, Name);
     return BBMap[Src] = BB;
   }
if (First == nullptr) {
       if (Last != nullptr) {
         fprintf(stderr, "Has no first instruction, but last one\n");
         exit(-1);
       }
 
       return BB;
     }
 
-    LLVMContextRef Ctx = LLVMGetModuleContext(LLVMGetGlobalParent(Fun));
     LLVMBuilderRef Builder = LLVMCreateBuilderInContext(Ctx);
     LLVMPositionBuilderAtEnd(Builder, BB);
 
     LLVMValueRef Cur = First;
     LLVMValueRef Next = nullptr;
     while(true) {
-      CloneValue(Cur, Builder);
+      CloneInstruction(Cur, Builder);
       Next = LLVMGetNextInstruction(Cur);
       if (Next == nullptr) {
         if (Cur != Last) {
           fprintf(stderr, "Final instruction does not match Last\n");
           exit(-1);
         }
 
         break;
static ValueMap clone_params(LLVMValueRef Src, LLVMValueRef Dst) {
   if (Count != 0) {
     fprintf(stderr, "Parameter count does not match iteration\n");
     exit(-1);
   }
 
   return VMap;
 }
 
-static LLVMValueRef clone_function(LLVMValueRef Src, LLVMModuleRef Dst) {
+static LLVMValueRef clone_function(LLVMValueRef Src, LLVMModuleRef M) {
   const char *Name = LLVMGetValueName(Src);
-  LLVMValueRef Fun = LLVMGetNamedFunction(Dst, Name);
+  LLVMValueRef Fun = LLVMGetNamedFunction(M, Name);
   if (Fun != nullptr)
     return Fun;
 
   LLVMTypeRef SrcTy = LLVMTypeOf(Src);
-  LLVMTypeRef DstTy = clone_type(SrcTy, LLVMGetModuleContext(Dst));
+  LLVMTypeRef DstTy = clone_type(SrcTy, LLVMGetModuleContext(M));
   LLVMTypeRef FunTy = LLVMGetElementType(DstTy);
 
-  Fun = LLVMAddFunction(Dst, Name, FunTy);
+  Fun = LLVMAddFunction(M, Name, FunTy);
   FunCloner FC(Src, Fun);
   FC.CloneBBs(Src);
 
   return Fun;
 }
 
 static void clone_functions(LLVMModuleRef Src, LLVMModuleRef Dst) {
   LLVMValueRef Begin = LLVMGetFirstFunction(Src);