llvm/tools/llvm-c-test/echo.cpp

   1 //===-- echo.cpp - tool for testing libLLVM and llvm-c API ----------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements the --echo command in llvm-c-test.
  10 //
  11 // This command uses the C API to read a module and output an exact copy of it
  12 // as output. It is used to check that the resulting module matches the input
  13 // to validate that the C API can read and write modules properly.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #include "llvm-c-test.h"
  18 #include "llvm-c/DebugInfo.h"
  19 #include "llvm-c/Target.h"
  20 #include "llvm/ADT/DenseMap.h"
  21 #include "llvm/Support/ErrorHandling.h"
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25
  26 using namespace llvm;
  27
  28 // Provide DenseMapInfo for C API opaque types.
  29 template<typename T>
  30 struct CAPIDenseMap {};
  31
  32 // The default DenseMapInfo require to know about pointer alignment.
  33 // Because the C API uses opaques pointer types, their alignment is unknown.
  34 // As a result, we need to roll out our own implementation.
  35 template<typename T>
  36 struct CAPIDenseMap<T*> {
  37   struct CAPIDenseMapInfo {
  38     static inline T* getEmptyKey() {
  39       uintptr_t Val = static_cast<uintptr_t>(-1);
  40       return reinterpret_cast<T*>(Val);
  41     }
  42     static inline T* getTombstoneKey() {
  43       uintptr_t Val = static_cast<uintptr_t>(-2);
  44       return reinterpret_cast<T*>(Val);
  45     }
  46     static unsigned getHashValue(const T *PtrVal) {
  47       return hash_value(PtrVal);
  48     }
  49     static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
  50   };
  51
  52   typedef DenseMap<T*, T*, CAPIDenseMapInfo> Map;
  53 };
  54
  55 typedef CAPIDenseMap<LLVMValueRef>::Map ValueMap;
  56 typedef CAPIDenseMap<LLVMBasicBlockRef>::Map BasicBlockMap;
  57
  58 struct TypeCloner {
  59   LLVMModuleRef M;
  60   LLVMContextRef Ctx;
  61
  62   TypeCloner(LLVMModuleRef M): M(M), Ctx(LLVMGetModuleContext(M)) {}
  63
  64   LLVMTypeRef Clone(LLVMValueRef Src) {
  65     return Clone(LLVMTypeOf(Src));
  66   }
  67
  68   LLVMTypeRef Clone(LLVMTypeRef Src) {
  69     LLVMTypeKind Kind = LLVMGetTypeKind(Src);
  70     switch (Kind) {
  71       case LLVMVoidTypeKind:
  72         return LLVMVoidTypeInContext(Ctx);
  73       case LLVMHalfTypeKind:
  74         return LLVMHalfTypeInContext(Ctx);
  75       case LLVMFloatTypeKind:
  76         return LLVMFloatTypeInContext(Ctx);
  77       case LLVMDoubleTypeKind:
  78         return LLVMDoubleTypeInContext(Ctx);
  79       case LLVMX86_FP80TypeKind:
  80         return LLVMX86FP80TypeInContext(Ctx);
  81       case LLVMFP128TypeKind:
  82         return LLVMFP128TypeInContext(Ctx);
  83       case LLVMPPC_FP128TypeKind:
  84         return LLVMPPCFP128TypeInContext(Ctx);
  85       case LLVMLabelTypeKind:
  86         return LLVMLabelTypeInContext(Ctx);
  87       case LLVMIntegerTypeKind:
  88         return LLVMIntTypeInContext(Ctx, LLVMGetIntTypeWidth(Src));
  89       case LLVMFunctionTypeKind: {
  90         unsigned ParamCount = LLVMCountParamTypes(Src);
  91         LLVMTypeRef* Params = nullptr;
  92         if (ParamCount > 0) {
  93           Params = static_cast<LLVMTypeRef*>(
  94               safe_malloc(ParamCount * sizeof(LLVMTypeRef)));
  95           LLVMGetParamTypes(Src, Params);
  96           for (unsigned i = 0; i < ParamCount; i++)
  97             Params[i] = Clone(Params[i]);
  98         }
  99
 100         LLVMTypeRef FunTy = LLVMFunctionType(Clone(LLVMGetReturnType(Src)),
 101                                              Params, ParamCount,
 102                                              LLVMIsFunctionVarArg(Src));
 103         if (ParamCount > 0)
 104           free(Params);
 105         return FunTy;
 106       }
 107       case LLVMStructTypeKind: {
 108         LLVMTypeRef S = nullptr;
 109         const char *Name = LLVMGetStructName(Src);
 110         if (Name) {
 111           S = LLVMGetTypeByName(M, Name);
 112           if (S)
 113             return S;
 114           S = LLVMStructCreateNamed(Ctx, Name);
 115           if (LLVMIsOpaqueStruct(Src))
 116             return S;
 117         }
 118
 119         unsigned EltCount = LLVMCountStructElementTypes(Src);
 120         SmallVector<LLVMTypeRef, 8> Elts;
 121         for (unsigned i = 0; i < EltCount; i++)
 122           Elts.push_back(Clone(LLVMStructGetTypeAtIndex(Src, i)));
 123         if (Name)
 124           LLVMStructSetBody(S, Elts.data(), EltCount, LLVMIsPackedStruct(Src));
 125         else
 126           S = LLVMStructTypeInContext(Ctx, Elts.data(), EltCount,
 127                                       LLVMIsPackedStruct(Src));
 128         return S;
 129       }
 130       case LLVMArrayTypeKind:
 131         return LLVMArrayType(
 132           Clone(LLVMGetElementType(Src)),
 133           LLVMGetArrayLength(Src)
 134         );
 135       case LLVMPointerTypeKind:
 136         return LLVMPointerType(
 137           Clone(LLVMGetElementType(Src)),
 138           LLVMGetPointerAddressSpace(Src)
 139         );
 140       case LLVMVectorTypeKind:
 141         return LLVMVectorType(
 142           Clone(LLVMGetElementType(Src)),
 143           LLVMGetVectorSize(Src)
 144         );
 145       case LLVMMetadataTypeKind:
 146         return LLVMMetadataTypeInContext(Ctx);
 147       case LLVMX86_MMXTypeKind:
 148         return LLVMX86MMXTypeInContext(Ctx);
 149       case LLVMTokenTypeKind:
 150         return LLVMTokenTypeInContext(Ctx);
 151     }
 152
 153     fprintf(stderr, "%d is not a supported typekind\n", Kind);
 154     exit(-1);
 155   }
 156 };
 157
 158 static ValueMap clone_params(LLVMValueRef Src, LLVMValueRef Dst) {
 159   unsigned Count = LLVMCountParams(Src);
 160   if (Count != LLVMCountParams(Dst))
 161     report_fatal_error("Parameter count mismatch");
 162
 163   ValueMap VMap;
 164   if (Count == 0)
 165     return VMap;
 166
 167   LLVMValueRef SrcFirst = LLVMGetFirstParam(Src);
 168   LLVMValueRef DstFirst = LLVMGetFirstParam(Dst);
 169   LLVMValueRef SrcLast = LLVMGetLastParam(Src);
 170   LLVMValueRef DstLast = LLVMGetLastParam(Dst);
 171
 172   LLVMValueRef SrcCur = SrcFirst;
 173   LLVMValueRef DstCur = DstFirst;
 174   LLVMValueRef SrcNext = nullptr;
 175   LLVMValueRef DstNext = nullptr;
 176   while (true) {
 177     size_t NameLen;
 178     const char *Name = LLVMGetValueName2(SrcCur, &NameLen);
 179     LLVMSetValueName2(DstCur, Name, NameLen);
 180
 181     VMap[SrcCur] = DstCur;
 182
 183     Count--;
 184     SrcNext = LLVMGetNextParam(SrcCur);
 185     DstNext = LLVMGetNextParam(DstCur);
 186     if (SrcNext == nullptr && DstNext == nullptr) {
 187       if (SrcCur != SrcLast)
 188         report_fatal_error("SrcLast param does not match End");
 189       if (DstCur != DstLast)
 190         report_fatal_error("DstLast param does not match End");
 191       break;
 192     }
 193
 194     if (SrcNext == nullptr)
 195       report_fatal_error("SrcNext was unexpectedly null");
 196     if (DstNext == nullptr)
 197       report_fatal_error("DstNext was unexpectedly null");
 198
 199     LLVMValueRef SrcPrev = LLVMGetPreviousParam(SrcNext);
 200     if (SrcPrev != SrcCur)
 201       report_fatal_error("SrcNext.Previous param is not Current");
 202
 203     LLVMValueRef DstPrev = LLVMGetPreviousParam(DstNext);
 204     if (DstPrev != DstCur)
 205       report_fatal_error("DstNext.Previous param is not Current");
 206
 207     SrcCur = SrcNext;
 208     DstCur = DstNext;
 209   }
 210
 211   if (Count != 0)
 212     report_fatal_error("Parameter count does not match iteration");
 213
 214   return VMap;
 215 }
 216
 217 static void check_value_kind(LLVMValueRef V, LLVMValueKind K) {
 218   if (LLVMGetValueKind(V) != K)
 219     report_fatal_error("LLVMGetValueKind returned incorrect type");
 220 }
 221
 222 static LLVMValueRef clone_constant_impl(LLVMValueRef Cst, LLVMModuleRef M);
 223
 224 static LLVMValueRef clone_constant(LLVMValueRef Cst, LLVMModuleRef M) {
 225   LLVMValueRef Ret = clone_constant_impl(Cst, M);
 226   check_value_kind(Ret, LLVMGetValueKind(Cst));
 227   return Ret;
 228 }
 229
 230 static LLVMValueRef clone_constant_impl(LLVMValueRef Cst, LLVMModuleRef M) {
 231   if (!LLVMIsAConstant(Cst))
 232     report_fatal_error("Expected a constant");
 233
 234   // Maybe it is a symbol
 235   if (LLVMIsAGlobalValue(Cst)) {
 236     size_t NameLen;
 237     const char *Name = LLVMGetValueName2(Cst, &NameLen);
 238
 239     // Try function
 240     if (LLVMIsAFunction(Cst)) {
 241       check_value_kind(Cst, LLVMFunctionValueKind);
 242
 243       LLVMValueRef Dst = nullptr;
 244       // Try an intrinsic
 245       unsigned ID = LLVMGetIntrinsicID(Cst);
 246       if (ID > 0 && !LLVMIntrinsicIsOverloaded(ID)) {
 247         Dst = LLVMGetIntrinsicDeclaration(M, ID, nullptr, 0);
 248       } else {
 249         // Try a normal function
 250         Dst = LLVMGetNamedFunction(M, Name);
 251       }
 252
 253       if (Dst)
 254         return Dst;
 255       report_fatal_error("Could not find function");
 256     }
 257
 258     // Try global variable
 259     if (LLVMIsAGlobalVariable(Cst)) {
 260       check_value_kind(Cst, LLVMGlobalVariableValueKind);
 261       LLVMValueRef Dst = LLVMGetNamedGlobal(M, Name);
 262       if (Dst)
 263         return Dst;
 264       report_fatal_error("Could not find variable");
 265     }
 266
 267     // Try global alias
 268     if (LLVMIsAGlobalAlias(Cst)) {
 269       check_value_kind(Cst, LLVMGlobalAliasValueKind);
 270       LLVMValueRef Dst = LLVMGetNamedGlobalAlias(M, Name, NameLen);
 271       if (Dst)
 272         return Dst;
 273       report_fatal_error("Could not find alias");
 274     }
 275
 276     fprintf(stderr, "Could not find @%s\n", Name);
 277     exit(-1);
 278   }
 279
 280   // Try integer literal
 281   if (LLVMIsAConstantInt(Cst)) {
 282     check_value_kind(Cst, LLVMConstantIntValueKind);
 283     return LLVMConstInt(TypeCloner(M).Clone(Cst),
 284                         LLVMConstIntGetZExtValue(Cst), false);
 285   }
 286
 287   // Try zeroinitializer
 288   if (LLVMIsAConstantAggregateZero(Cst)) {
 289     check_value_kind(Cst, LLVMConstantAggregateZeroValueKind);
 290     return LLVMConstNull(TypeCloner(M).Clone(Cst));
 291   }
 292
 293   // Try constant array
 294   if (LLVMIsAConstantArray(Cst)) {
 295     check_value_kind(Cst, LLVMConstantArrayValueKind);
 296     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
 297     unsigned EltCount = LLVMGetArrayLength(Ty);
 298     SmallVector<LLVMValueRef, 8> Elts;
 299     for (unsigned i = 0; i < EltCount; i++)
 300       Elts.push_back(clone_constant(LLVMGetOperand(Cst, i), M));
 301     return LLVMConstArray(LLVMGetElementType(Ty), Elts.data(), EltCount);
 302   }
 303
 304   // Try contant data array
 305   if (LLVMIsAConstantDataArray(Cst)) {
 306     check_value_kind(Cst, LLVMConstantDataArrayValueKind);
 307     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
 308     unsigned EltCount = LLVMGetArrayLength(Ty);
 309     SmallVector<LLVMValueRef, 8> Elts;
 310     for (unsigned i = 0; i < EltCount; i++)
 311       Elts.push_back(clone_constant(LLVMGetElementAsConstant(Cst, i), M));
 312     return LLVMConstArray(LLVMGetElementType(Ty), Elts.data(), EltCount);
 313   }
 314
 315   // Try constant struct
 316   if (LLVMIsAConstantStruct(Cst)) {
 317     check_value_kind(Cst, LLVMConstantStructValueKind);
 318     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
 319     unsigned EltCount = LLVMCountStructElementTypes(Ty);
 320     SmallVector<LLVMValueRef, 8> Elts;
 321     for (unsigned i = 0; i < EltCount; i++)
 322       Elts.push_back(clone_constant(LLVMGetOperand(Cst, i), M));
 323     if (LLVMGetStructName(Ty))
 324       return LLVMConstNamedStruct(Ty, Elts.data(), EltCount);
 325     return LLVMConstStructInContext(LLVMGetModuleContext(M), Elts.data(),
 326                                     EltCount, LLVMIsPackedStruct(Ty));
 327   }
 328
 329   // Try ConstantPointerNull
 330   if (LLVMIsAConstantPointerNull(Cst)) {
 331     check_value_kind(Cst, LLVMConstantPointerNullValueKind);
 332     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
 333     return LLVMConstNull(Ty);
 334   }
 335
 336   // Try undef
 337   if (LLVMIsUndef(Cst)) {
 338     check_value_kind(Cst, LLVMUndefValueValueKind);
 339     return LLVMGetUndef(TypeCloner(M).Clone(Cst));
 340   }
 341
 342   // Try null
 343   if (LLVMIsNull(Cst)) {
 344     check_value_kind(Cst, LLVMConstantTokenNoneValueKind);
 345     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
 346     return LLVMConstNull(Ty);
 347   }
 348
 349   // Try float literal
 350   if (LLVMIsAConstantFP(Cst)) {
 351     check_value_kind(Cst, LLVMConstantFPValueKind);
 352     report_fatal_error("ConstantFP is not supported");
 353   }
 354
 355   // This kind of constant is not supported
 356   if (!LLVMIsAConstantExpr(Cst))
 357     report_fatal_error("Expected a constant expression");
 358
 359   // At this point, it must be a constant expression
 360   check_value_kind(Cst, LLVMConstantExprValueKind);
 361
 362   LLVMOpcode Op = LLVMGetConstOpcode(Cst);
 363   switch(Op) {
 364     case LLVMBitCast:
 365       return LLVMConstBitCast(clone_constant(LLVMGetOperand(Cst, 0), M),
 366                               TypeCloner(M).Clone(Cst));
 367     default:
 368       fprintf(stderr, "%d is not a supported opcode\n", Op);
 369       exit(-1);
 370   }
 371 }
 372
 373 struct FunCloner {
 374   LLVMValueRef Fun;
 375   LLVMModuleRef M;
 376
 377   ValueMap VMap;
 378   BasicBlockMap BBMap;
 379
 380   FunCloner(LLVMValueRef Src, LLVMValueRef Dst): Fun(Dst),
 381     M(LLVMGetGlobalParent(Fun)), VMap(clone_params(Src, Dst)) {}
 382
 383   LLVMTypeRef CloneType(LLVMTypeRef Src) {
 384     return TypeCloner(M).Clone(Src);
 385   }
 386
 387   LLVMTypeRef CloneType(LLVMValueRef Src) {
 388     return TypeCloner(M).Clone(Src);
 389   }
 390
 391   // Try to clone everything in the llvm::Value hierarchy.
 392   LLVMValueRef CloneValue(LLVMValueRef Src) {
 393     // First, the value may be constant.
 394     if (LLVMIsAConstant(Src))
 395       return clone_constant(Src, M);
 396
 397     // Function argument should always be in the map already.
 398     auto i = VMap.find(Src);
 399     if (i != VMap.end())
 400       return i->second;
 401
 402     if (!LLVMIsAInstruction(Src))
 403       report_fatal_error("Expected an instruction");
 404
 405     auto Ctx = LLVMGetModuleContext(M);
 406     auto Builder = LLVMCreateBuilderInContext(Ctx);
 407     auto BB = DeclareBB(LLVMGetInstructionParent(Src));
 408     LLVMPositionBuilderAtEnd(Builder, BB);
 409     auto Dst = CloneInstruction(Src, Builder);
 410     LLVMDisposeBuilder(Builder);
 411     return Dst;
 412   }
 413
 414   void CloneAttrs(LLVMValueRef Src, LLVMValueRef Dst) {
 415     auto Ctx = LLVMGetModuleContext(M);
 416     int ArgCount = LLVMGetNumArgOperands(Src);
 417     for (int i = LLVMAttributeReturnIndex; i <= ArgCount; i++) {
 418       for (unsigned k = 0, e = LLVMGetLastEnumAttributeKind(); k < e; ++k) {
 419         if (auto SrcA = LLVMGetCallSiteEnumAttribute(Src, i, k)) {
 420           auto Val = LLVMGetEnumAttributeValue(SrcA);
 421           auto A = LLVMCreateEnumAttribute(Ctx, k, Val);
 422           LLVMAddCallSiteAttribute(Dst, i, A);
 423         }
 424       }
 425     }
 426   }
 427
 428   LLVMValueRef CloneInstruction(LLVMValueRef Src, LLVMBuilderRef Builder) {
 429     check_value_kind(Src, LLVMInstructionValueKind);
 430     if (!LLVMIsAInstruction(Src))
 431       report_fatal_error("Expected an instruction");
 432
 433     size_t NameLen;
 434     const char *Name = LLVMGetValueName2(Src, &NameLen);
 435
 436     // Check if this is something we already computed.
 437     {
 438       auto i = VMap.find(Src);
 439       if (i != VMap.end()) {
 440         // If we have a hit, it means we already generated the instruction
 441         // as a dependancy to somethign else. We need to make sure
 442         // it is ordered properly.
 443         auto I = i->second;
 444         LLVMInstructionRemoveFromParent(I);
 445         LLVMInsertIntoBuilderWithName(Builder, I, Name);
 446         return I;
 447       }
 448     }
 449
 450     // We tried everything, it must be an instruction
 451     // that hasn't been generated already.
 452     LLVMValueRef Dst = nullptr;
 453
 454     LLVMOpcode Op = LLVMGetInstructionOpcode(Src);
 455     switch(Op) {
 456       case LLVMRet: {
 457         int OpCount = LLVMGetNumOperands(Src);
 458         if (OpCount == 0)
 459           Dst = LLVMBuildRetVoid(Builder);
 460         else
 461           Dst = LLVMBuildRet(Builder, CloneValue(LLVMGetOperand(Src, 0)));
 462         break;
 463       }
 464       case LLVMBr: {
 465         if (!LLVMIsConditional(Src)) {
 466           LLVMValueRef SrcOp = LLVMGetOperand(Src, 0);
 467           LLVMBasicBlockRef SrcBB = LLVMValueAsBasicBlock(SrcOp);
 468           Dst = LLVMBuildBr(Builder, DeclareBB(SrcBB));
 469           break;
 470         }
 471
 472         LLVMValueRef Cond = LLVMGetCondition(Src);
 473         LLVMValueRef Else = LLVMGetOperand(Src, 1);
 474         LLVMBasicBlockRef ElseBB = DeclareBB(LLVMValueAsBasicBlock(Else));
 475         LLVMValueRef Then = LLVMGetOperand(Src, 2);
 476         LLVMBasicBlockRef ThenBB = DeclareBB(LLVMValueAsBasicBlock(Then));
 477         Dst = LLVMBuildCondBr(Builder, CloneValue(Cond), ThenBB, ElseBB);
 478         break;
 479       }
 480       case LLVMSwitch:
 481       case LLVMIndirectBr:
 482         break;
 483       case LLVMInvoke: {
 484         SmallVector<LLVMValueRef, 8> Args;
 485         int ArgCount = LLVMGetNumArgOperands(Src);
 486         for (int i = 0; i < ArgCount; i++)
 487           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
 488         LLVMValueRef Fn = CloneValue(LLVMGetCalledValue(Src));
 489         LLVMBasicBlockRef Then = DeclareBB(LLVMGetNormalDest(Src));
 490         LLVMBasicBlockRef Unwind = DeclareBB(LLVMGetUnwindDest(Src));
 491         Dst = LLVMBuildInvoke(Builder, Fn, Args.data(), ArgCount,
 492                               Then, Unwind, Name);
 493         CloneAttrs(Src, Dst);
 494         break;
 495       }
 496       case LLVMUnreachable:
 497         Dst = LLVMBuildUnreachable(Builder);
 498         break;
 499       case LLVMAdd: {
 500         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
 501         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
 502         Dst = LLVMBuildAdd(Builder, LHS, RHS, Name);
 503         break;
 504       }
 505       case LLVMSub: {
 506         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
 507         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
 508         Dst = LLVMBuildSub(Builder, LHS, RHS, Name);
 509         break;
 510       }
 511       case LLVMMul: {
 512         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
 513         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
 514         Dst = LLVMBuildMul(Builder, LHS, RHS, Name);
 515         break;
 516       }
 517       case LLVMUDiv: {
 518         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
 519         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
 520         Dst = LLVMBuildUDiv(Builder, LHS, RHS, Name);
 521         break;
 522       }
 523       case LLVMSDiv: {
 524         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
 525         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
 526         Dst = LLVMBuildSDiv(Builder, LHS, RHS, Name);
 527         break;
 528       }
 529       case LLVMURem: {
 530         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
 531         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
 532         Dst = LLVMBuildURem(Builder, LHS, RHS, Name);
 533         break;
 534       }
 535       case LLVMSRem: {
 536         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
 537         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
 538         Dst = LLVMBuildSRem(Builder, LHS, RHS, Name);
 539         break;
 540       }
 541       case LLVMShl: {
 542         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
 543         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
 544         Dst = LLVMBuildShl(Builder, LHS, RHS, Name);
 545         break;
 546       }
 547       case LLVMLShr: {
 548         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
 549         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
 550         Dst = LLVMBuildLShr(Builder, LHS, RHS, Name);
 551         break;
 552       }
 553       case LLVMAShr: {
 554         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
 555         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
 556         Dst = LLVMBuildAShr(Builder, LHS, RHS, Name);
 557         break;
 558       }
 559       case LLVMAnd: {
 560         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
 561         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
 562         Dst = LLVMBuildAnd(Builder, LHS, RHS, Name);
 563         break;
 564       }
 565       case LLVMOr: {
 566         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
 567         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
 568         Dst = LLVMBuildOr(Builder, LHS, RHS, Name);
 569         break;
 570       }
 571       case LLVMXor: {
 572         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
 573         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
 574         Dst = LLVMBuildXor(Builder, LHS, RHS, Name);
 575         break;
 576       }
 577       case LLVMAlloca: {
 578         LLVMTypeRef Ty = CloneType(LLVMGetAllocatedType(Src));
 579         Dst = LLVMBuildAlloca(Builder, Ty, Name);
 580         break;
 581       }
 582       case LLVMLoad: {
 583         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
 584         Dst = LLVMBuildLoad(Builder, Ptr, Name);
 585         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
 586         LLVMSetOrdering(Dst, LLVMGetOrdering(Src));
 587         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
 588         break;
 589       }
 590       case LLVMStore: {
 591         LLVMValueRef Val = CloneValue(LLVMGetOperand(Src, 0));
 592         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 1));
 593         Dst = LLVMBuildStore(Builder, Val, Ptr);
 594         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
 595         LLVMSetOrdering(Dst, LLVMGetOrdering(Src));
 596         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
 597         break;
 598       }
 599       case LLVMGetElementPtr: {
 600         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
 601         SmallVector<LLVMValueRef, 8> Idx;
 602         int NumIdx = LLVMGetNumIndices(Src);
 603         for (int i = 1; i <= NumIdx; i++)
 604           Idx.push_back(CloneValue(LLVMGetOperand(Src, i)));
 605         if (LLVMIsInBounds(Src))
 606           Dst = LLVMBuildInBoundsGEP(Builder, Ptr, Idx.data(), NumIdx, Name);
 607         else
 608           Dst = LLVMBuildGEP(Builder, Ptr, Idx.data(), NumIdx, Name);
 609         break;
 610       }
 611       case LLVMAtomicRMW: {
 612         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
 613         LLVMValueRef Val = CloneValue(LLVMGetOperand(Src, 1));
 614         LLVMAtomicRMWBinOp BinOp = LLVMGetAtomicRMWBinOp(Src);
 615         LLVMAtomicOrdering Ord = LLVMGetOrdering(Src);
 616         LLVMBool SingleThread = LLVMIsAtomicSingleThread(Src);
 617         Dst = LLVMBuildAtomicRMW(Builder, BinOp, Ptr, Val, Ord, SingleThread);
 618         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
 619         LLVMSetValueName2(Dst, Name, NameLen);
 620         break;
 621       }
 622       case LLVMAtomicCmpXchg: {
 623         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
 624         LLVMValueRef Cmp = CloneValue(LLVMGetOperand(Src, 1));
 625         LLVMValueRef New = CloneValue(LLVMGetOperand(Src, 2));
 626         LLVMAtomicOrdering Succ = LLVMGetCmpXchgSuccessOrdering(Src);
 627         LLVMAtomicOrdering Fail = LLVMGetCmpXchgFailureOrdering(Src);
 628         LLVMBool SingleThread = LLVMIsAtomicSingleThread(Src);
 629
 630         Dst = LLVMBuildAtomicCmpXchg(Builder, Ptr, Cmp, New, Succ, Fail,
 631                                      SingleThread);
 632         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
 633         LLVMSetWeak(Dst, LLVMGetWeak(Src));
 634         LLVMSetValueName2(Dst, Name, NameLen);
 635         break;
 636       }
 637       case LLVMBitCast: {
 638         LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 0));
 639         Dst = LLVMBuildBitCast(Builder, V, CloneType(Src), Name);
 640         break;
 641       }
 642       case LLVMICmp: {
 643         LLVMIntPredicate Pred = LLVMGetICmpPredicate(Src);
 644         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
 645         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
 646         Dst = LLVMBuildICmp(Builder, Pred, LHS, RHS, Name);
 647         break;
 648       }
 649       case LLVMPHI: {
 650         // We need to aggressively set things here because of loops.
 651         VMap[Src] = Dst = LLVMBuildPhi(Builder, CloneType(Src), Name);
 652
 653         SmallVector<LLVMValueRef, 8> Values;
 654         SmallVector<LLVMBasicBlockRef, 8> Blocks;
 655
 656         unsigned IncomingCount = LLVMCountIncoming(Src);
 657         for (unsigned i = 0; i < IncomingCount; ++i) {
 658           Blocks.push_back(DeclareBB(LLVMGetIncomingBlock(Src, i)));
 659           Values.push_back(CloneValue(LLVMGetIncomingValue(Src, i)));
 660         }
 661
 662         LLVMAddIncoming(Dst, Values.data(), Blocks.data(), IncomingCount);
 663         return Dst;
 664       }
 665       case LLVMCall: {
 666         SmallVector<LLVMValueRef, 8> Args;
 667         int ArgCount = LLVMGetNumArgOperands(Src);
 668         for (int i = 0; i < ArgCount; i++)
 669           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
 670         LLVMValueRef Fn = CloneValue(LLVMGetCalledValue(Src));
 671         Dst = LLVMBuildCall(Builder, Fn, Args.data(), ArgCount, Name);
 672         LLVMSetTailCall(Dst, LLVMIsTailCall(Src));
 673         CloneAttrs(Src, Dst);
 674         break;
 675       }
 676       case LLVMResume: {
 677         Dst = LLVMBuildResume(Builder, CloneValue(LLVMGetOperand(Src, 0)));
 678         break;
 679       }
 680       case LLVMLandingPad: {
 681         // The landing pad API is a bit screwed up for historical reasons.
 682         Dst = LLVMBuildLandingPad(Builder, CloneType(Src), nullptr, 0, Name);
 683         unsigned NumClauses = LLVMGetNumClauses(Src);
 684         for (unsigned i = 0; i < NumClauses; ++i)
 685           LLVMAddClause(Dst, CloneValue(LLVMGetClause(Src, i)));
 686         LLVMSetCleanup(Dst, LLVMIsCleanup(Src));
 687         break;
 688       }
 689       case LLVMCleanupRet: {
 690         LLVMValueRef CatchPad = CloneValue(LLVMGetOperand(Src, 0));
 691         LLVMBasicBlockRef Unwind = nullptr;
 692         if (LLVMBasicBlockRef UDest = LLVMGetUnwindDest(Src))
 693           Unwind = DeclareBB(UDest);
 694         Dst = LLVMBuildCleanupRet(Builder, CatchPad, Unwind);
 695         break;
 696       }
 697       case LLVMCatchRet: {
 698         LLVMValueRef CatchPad = CloneValue(LLVMGetOperand(Src, 0));
 699         LLVMBasicBlockRef SuccBB = DeclareBB(LLVMGetSuccessor(Src, 0));
 700         Dst = LLVMBuildCatchRet(Builder, CatchPad, SuccBB);
 701         break;
 702       }
 703       case LLVMCatchPad: {
 704         LLVMValueRef ParentPad = CloneValue(LLVMGetParentCatchSwitch(Src));
 705         SmallVector<LLVMValueRef, 8> Args;
 706         int ArgCount = LLVMGetNumArgOperands(Src);
 707         for (int i = 0; i < ArgCount; i++)
 708           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
 709         Dst = LLVMBuildCatchPad(Builder, ParentPad,
 710                                 Args.data(), ArgCount, Name);
 711         break;
 712       }
 713       case LLVMCleanupPad: {
 714         LLVMValueRef ParentPad = CloneValue(LLVMGetOperand(Src, 0));
 715         SmallVector<LLVMValueRef, 8> Args;
 716         int ArgCount = LLVMGetNumArgOperands(Src);
 717         for (int i = 0; i < ArgCount; i++)
 718           Args.push_back(CloneValue(LLVMGetArgOperand(Src, i)));
 719         Dst = LLVMBuildCleanupPad(Builder, ParentPad,
 720                                   Args.data(), ArgCount, Name);
 721         break;
 722       }
 723       case LLVMCatchSwitch: {
 724         LLVMValueRef ParentPad = CloneValue(LLVMGetOperand(Src, 0));
 725         LLVMBasicBlockRef UnwindBB = nullptr;
 726         if (LLVMBasicBlockRef UDest = LLVMGetUnwindDest(Src)) {
 727           UnwindBB = DeclareBB(UDest);
 728         }
 729         unsigned NumHandlers = LLVMGetNumHandlers(Src);
 730         Dst = LLVMBuildCatchSwitch(Builder, ParentPad, UnwindBB, NumHandlers, Name);
 731         if (NumHandlers > 0) {
 732           LLVMBasicBlockRef *Handlers = static_cast<LLVMBasicBlockRef*>(
 733                        safe_malloc(NumHandlers * sizeof(LLVMBasicBlockRef)));
 734           LLVMGetHandlers(Src, Handlers);
 735           for (unsigned i = 0; i < NumHandlers; i++)
 736             LLVMAddHandler(Dst, DeclareBB(Handlers[i]));
 737           free(Handlers);
 738         }
 739         break;
 740       }
 741       case LLVMExtractValue: {
 742         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
 743         if (LLVMGetNumIndices(Src) != 1)
 744           report_fatal_error("Expected only one indice");
 745         auto I = LLVMGetIndices(Src)[0];
 746         Dst = LLVMBuildExtractValue(Builder, Agg, I, Name);
 747         break;
 748       }
 749       case LLVMInsertValue: {
 750         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
 751         LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 1));
 752         if (LLVMGetNumIndices(Src) != 1)
 753           report_fatal_error("Expected only one indice");
 754         auto I = LLVMGetIndices(Src)[0];
 755         Dst = LLVMBuildInsertValue(Builder, Agg, V, I, Name);
 756         break;
 757       }
 758       case LLVMFreeze: {
 759         LLVMValueRef Arg = CloneValue(LLVMGetOperand(Src, 0));
 760         Dst = LLVMBuildFreeze(Builder, Arg, Name);
 761         break;
 762       }
 763       default:
 764         break;
 765     }
 766
 767     if (Dst == nullptr) {
 768       fprintf(stderr, "%d is not a supported opcode\n", Op);
 769       exit(-1);
 770     }
 771
 772     auto Ctx = LLVMGetModuleContext(M);
 773     size_t NumMetadataEntries;
 774     auto *AllMetadata =
 775         LLVMInstructionGetAllMetadataOtherThanDebugLoc(Src,
 776                                                        &NumMetadataEntries);
 777     for (unsigned i = 0; i < NumMetadataEntries; ++i) {
 778       unsigned Kind = LLVMValueMetadataEntriesGetKind(AllMetadata, i);
 779       LLVMMetadataRef MD = LLVMValueMetadataEntriesGetMetadata(AllMetadata, i);
 780       LLVMSetMetadata(Dst, Kind, LLVMMetadataAsValue(Ctx, MD));
 781     }
 782     LLVMDisposeValueMetadataEntries(AllMetadata);
 783     LLVMSetInstDebugLocation(Builder, Dst);
 784
 785     check_value_kind(Dst, LLVMInstructionValueKind);
 786     return VMap[Src] = Dst;
 787   }
 788
 789   LLVMBasicBlockRef DeclareBB(LLVMBasicBlockRef Src) {
 790     // Check if this is something we already computed.
 791     {
 792       auto i = BBMap.find(Src);
 793       if (i != BBMap.end()) {
 794         return i->second;
 795       }
 796     }
 797
 798     LLVMValueRef V = LLVMBasicBlockAsValue(Src);
 799     if (!LLVMValueIsBasicBlock(V) || LLVMValueAsBasicBlock(V) != Src)
 800       report_fatal_error("Basic block is not a basic block");
 801
 802     const char *Name = LLVMGetBasicBlockName(Src);
 803     size_t NameLen;
 804     const char *VName = LLVMGetValueName2(V, &NameLen);
 805     if (Name != VName)
 806       report_fatal_error("Basic block name mismatch");
 807
 808     LLVMBasicBlockRef BB = LLVMAppendBasicBlock(Fun, Name);
 809     return BBMap[Src] = BB;
 810   }
 811
 812   LLVMBasicBlockRef CloneBB(LLVMBasicBlockRef Src) {
 813     LLVMBasicBlockRef BB = DeclareBB(Src);
 814
 815     // Make sure ordering is correct.
 816     LLVMBasicBlockRef Prev = LLVMGetPreviousBasicBlock(Src);
 817     if (Prev)
 818       LLVMMoveBasicBlockAfter(BB, DeclareBB(Prev));
 819
 820     LLVMValueRef First = LLVMGetFirstInstruction(Src);
 821     LLVMValueRef Last = LLVMGetLastInstruction(Src);
 822
 823     if (First == nullptr) {
 824       if (Last != nullptr)
 825         report_fatal_error("Has no first instruction, but last one");
 826       return BB;
 827     }
 828
 829     auto Ctx = LLVMGetModuleContext(M);
 830     LLVMBuilderRef Builder = LLVMCreateBuilderInContext(Ctx);
 831     LLVMPositionBuilderAtEnd(Builder, BB);
 832
 833     LLVMValueRef Cur = First;
 834     LLVMValueRef Next = nullptr;
 835     while(true) {
 836       CloneInstruction(Cur, Builder);
 837       Next = LLVMGetNextInstruction(Cur);
 838       if (Next == nullptr) {
 839         if (Cur != Last)
 840           report_fatal_error("Final instruction does not match Last");
 841         break;
 842       }
 843
 844       LLVMValueRef Prev = LLVMGetPreviousInstruction(Next);
 845       if (Prev != Cur)
 846         report_fatal_error("Next.Previous instruction is not Current");
 847
 848       Cur = Next;
 849     }
 850
 851     LLVMDisposeBuilder(Builder);
 852     return BB;
 853   }
 854
 855   void CloneBBs(LLVMValueRef Src) {
 856     unsigned Count = LLVMCountBasicBlocks(Src);
 857     if (Count == 0)
 858       return;
 859
 860     LLVMBasicBlockRef First = LLVMGetFirstBasicBlock(Src);
 861     LLVMBasicBlockRef Last = LLVMGetLastBasicBlock(Src);
 862
 863     LLVMBasicBlockRef Cur = First;
 864     LLVMBasicBlockRef Next = nullptr;
 865     while(true) {
 866       CloneBB(Cur);
 867       Count--;
 868       Next = LLVMGetNextBasicBlock(Cur);
 869       if (Next == nullptr) {
 870         if (Cur != Last)
 871           report_fatal_error("Final basic block does not match Last");
 872         break;
 873       }
 874
 875       LLVMBasicBlockRef Prev = LLVMGetPreviousBasicBlock(Next);
 876       if (Prev != Cur)
 877         report_fatal_error("Next.Previous basic bloc is not Current");
 878
 879       Cur = Next;
 880     }
 881
 882     if (Count != 0)
 883       report_fatal_error("Basic block count does not match iterration");
 884   }
 885 };
 886
 887 static void declare_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
 888   auto Ctx = LLVMGetModuleContext(M);
 889
 890   LLVMValueRef Begin = LLVMGetFirstGlobal(Src);
 891   LLVMValueRef End = LLVMGetLastGlobal(Src);
 892
 893   LLVMValueRef Cur = Begin;
 894   LLVMValueRef Next = nullptr;
 895   if (!Begin) {
 896     if (End != nullptr)
 897       report_fatal_error("Range has an end but no beginning");
 898     goto FunDecl;
 899   }
 900
 901   while (true) {
 902     size_t NameLen;
 903     const char *Name = LLVMGetValueName2(Cur, &NameLen);
 904     if (LLVMGetNamedGlobal(M, Name))
 905       report_fatal_error("GlobalVariable already cloned");
 906     LLVMAddGlobal(M, LLVMGetElementType(TypeCloner(M).Clone(Cur)), Name);
 907
 908     Next = LLVMGetNextGlobal(Cur);
 909     if (Next == nullptr) {
 910       if (Cur != End)
 911         report_fatal_error("");
 912       break;
 913     }
 914
 915     LLVMValueRef Prev = LLVMGetPreviousGlobal(Next);
 916     if (Prev != Cur)
 917       report_fatal_error("Next.Previous global is not Current");
 918
 919     Cur = Next;
 920   }
 921
 922 FunDecl:
 923   Begin = LLVMGetFirstFunction(Src);
 924   End = LLVMGetLastFunction(Src);
 925   if (!Begin) {
 926     if (End != nullptr)
 927       report_fatal_error("Range has an end but no beginning");
 928     goto AliasDecl;
 929   }
 930
 931   Cur = Begin;
 932   Next = nullptr;
 933   while (true) {
 934     size_t NameLen;
 935     const char *Name = LLVMGetValueName2(Cur, &NameLen);
 936     if (LLVMGetNamedFunction(M, Name))
 937       report_fatal_error("Function already cloned");
 938     auto Ty = LLVMGetElementType(TypeCloner(M).Clone(Cur));
 939     auto F = LLVMAddFunction(M, Name, Ty);
 940
 941     // Copy attributes
 942     for (int i = LLVMAttributeFunctionIndex, c = LLVMCountParams(F);
 943          i <= c; ++i) {
 944       for (unsigned k = 0, e = LLVMGetLastEnumAttributeKind(); k < e; ++k) {
 945         if (auto SrcA = LLVMGetEnumAttributeAtIndex(Cur, i, k)) {
 946           auto Val = LLVMGetEnumAttributeValue(SrcA);
 947           auto DstA = LLVMCreateEnumAttribute(Ctx, k, Val);
 948           LLVMAddAttributeAtIndex(F, i, DstA);
 949         }
 950       }
 951     }
 952
 953     Next = LLVMGetNextFunction(Cur);
 954     if (Next == nullptr) {
 955       if (Cur != End)
 956         report_fatal_error("Last function does not match End");
 957       break;
 958     }
 959
 960     LLVMValueRef Prev = LLVMGetPreviousFunction(Next);
 961     if (Prev != Cur)
 962       report_fatal_error("Next.Previous function is not Current");
 963
 964     Cur = Next;
 965   }
 966
 967 AliasDecl:
 968   Begin = LLVMGetFirstGlobalAlias(Src);
 969   End = LLVMGetLastGlobalAlias(Src);
 970   if (!Begin) {
 971     if (End != nullptr)
 972       report_fatal_error("Range has an end but no beginning");
 973     goto GlobalIFuncDecl;
 974   }
 975
 976   Cur = Begin;
 977   Next = nullptr;
 978   while (true) {
 979     size_t NameLen;
 980     const char *Name = LLVMGetValueName2(Cur, &NameLen);
 981     if (LLVMGetNamedGlobalAlias(M, Name, NameLen))
 982       report_fatal_error("Global alias already cloned");
 983     LLVMTypeRef CurType = TypeCloner(M).Clone(Cur);
 984     // FIXME: Allow NULL aliasee.
 985     LLVMAddAlias(M, CurType, LLVMGetUndef(CurType), Name);
 986
 987     Next = LLVMGetNextGlobalAlias(Cur);
 988     if (Next == nullptr) {
 989       if (Cur != End)
 990         report_fatal_error("");
 991       break;
 992     }
 993
 994     LLVMValueRef Prev = LLVMGetPreviousGlobalAlias(Next);
 995     if (Prev != Cur)
 996       report_fatal_error("Next.Previous global is not Current");
 997
 998     Cur = Next;
 999   }
1000
1001 GlobalIFuncDecl:
1002   Begin = LLVMGetFirstGlobalIFunc(Src);
1003   End = LLVMGetLastGlobalIFunc(Src);
1004   if (!Begin) {
1005     if (End != nullptr)
1006       report_fatal_error("Range has an end but no beginning");
1007     goto NamedMDDecl;
1008   }
1009
1010   Cur = Begin;
1011   Next = nullptr;
1012   while (true) {
1013     size_t NameLen;
1014     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1015     if (LLVMGetNamedGlobalIFunc(M, Name, NameLen))
1016       report_fatal_error("Global ifunc already cloned");
1017     LLVMTypeRef CurType = TypeCloner(M).Clone(LLVMGlobalGetValueType(Cur));
1018     // FIXME: Allow NULL resolver.
1019     LLVMAddGlobalIFunc(M, Name, NameLen,
1020                        CurType, /*addressSpace*/ 0, LLVMGetUndef(CurType));
1021
1022     Next = LLVMGetNextGlobalIFunc(Cur);
1023     if (Next == nullptr) {
1024       if (Cur != End)
1025         report_fatal_error("");
1026       break;
1027     }
1028
1029     LLVMValueRef Prev = LLVMGetPreviousGlobalIFunc(Next);
1030     if (Prev != Cur)
1031       report_fatal_error("Next.Previous global is not Current");
1032
1033     Cur = Next;
1034   }
1035
1036 NamedMDDecl:
1037   LLVMNamedMDNodeRef BeginMD = LLVMGetFirstNamedMetadata(Src);
1038   LLVMNamedMDNodeRef EndMD = LLVMGetLastNamedMetadata(Src);
1039   if (!BeginMD) {
1040     if (EndMD != nullptr)
1041       report_fatal_error("Range has an end but no beginning");
1042     return;
1043   }
1044
1045   LLVMNamedMDNodeRef CurMD = BeginMD;
1046   LLVMNamedMDNodeRef NextMD = nullptr;
1047   while (true) {
1048     size_t NameLen;
1049     const char *Name = LLVMGetNamedMetadataName(CurMD, &NameLen);
1050     if (LLVMGetNamedMetadata(M, Name, NameLen))
1051       report_fatal_error("Named Metadata Node already cloned");
1052     LLVMGetOrInsertNamedMetadata(M, Name, NameLen);
1053
1054     NextMD = LLVMGetNextNamedMetadata(CurMD);
1055     if (NextMD == nullptr) {
1056       if (CurMD != EndMD)
1057         report_fatal_error("");
1058       break;
1059     }
1060
1061     LLVMNamedMDNodeRef PrevMD = LLVMGetPreviousNamedMetadata(NextMD);
1062     if (PrevMD != CurMD)
1063       report_fatal_error("Next.Previous global is not Current");
1064
1065     CurMD = NextMD;
1066   }
1067 }
1068
1069 static void clone_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
1070   LLVMValueRef Begin = LLVMGetFirstGlobal(Src);
1071   LLVMValueRef End = LLVMGetLastGlobal(Src);
1072
1073   LLVMValueRef Cur = Begin;
1074   LLVMValueRef Next = nullptr;
1075   if (!Begin) {
1076     if (End != nullptr)
1077       report_fatal_error("Range has an end but no beginning");
1078     goto FunClone;
1079   }
1080
1081   while (true) {
1082     size_t NameLen;
1083     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1084     LLVMValueRef G = LLVMGetNamedGlobal(M, Name);
1085     if (!G)
1086       report_fatal_error("GlobalVariable must have been declared already");
1087
1088     if (auto I = LLVMGetInitializer(Cur))
1089       LLVMSetInitializer(G, clone_constant(I, M));
1090
1091     size_t NumMetadataEntries;
1092     auto *AllMetadata = LLVMGlobalCopyAllMetadata(Cur, &NumMetadataEntries);
1093     for (unsigned i = 0; i < NumMetadataEntries; ++i) {
1094       unsigned Kind = LLVMValueMetadataEntriesGetKind(AllMetadata, i);
1095       LLVMMetadataRef MD = LLVMValueMetadataEntriesGetMetadata(AllMetadata, i);
1096       LLVMGlobalSetMetadata(G, Kind, MD);
1097     }
1098     LLVMDisposeValueMetadataEntries(AllMetadata);
1099
1100     LLVMSetGlobalConstant(G, LLVMIsGlobalConstant(Cur));
1101     LLVMSetThreadLocal(G, LLVMIsThreadLocal(Cur));
1102     LLVMSetExternallyInitialized(G, LLVMIsExternallyInitialized(Cur));
1103     LLVMSetLinkage(G, LLVMGetLinkage(Cur));
1104     LLVMSetSection(G, LLVMGetSection(Cur));
1105     LLVMSetVisibility(G, LLVMGetVisibility(Cur));
1106     LLVMSetUnnamedAddress(G, LLVMGetUnnamedAddress(Cur));
1107     LLVMSetAlignment(G, LLVMGetAlignment(Cur));
1108
1109     Next = LLVMGetNextGlobal(Cur);
1110     if (Next == nullptr) {
1111       if (Cur != End)
1112         report_fatal_error("");
1113       break;
1114     }
1115
1116     LLVMValueRef Prev = LLVMGetPreviousGlobal(Next);
1117     if (Prev != Cur)
1118       report_fatal_error("Next.Previous global is not Current");
1119
1120     Cur = Next;
1121   }
1122
1123 FunClone:
1124   Begin = LLVMGetFirstFunction(Src);
1125   End = LLVMGetLastFunction(Src);
1126   if (!Begin) {
1127     if (End != nullptr)
1128       report_fatal_error("Range has an end but no beginning");
1129     goto AliasClone;
1130   }
1131
1132   Cur = Begin;
1133   Next = nullptr;
1134   while (true) {
1135     size_t NameLen;
1136     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1137     LLVMValueRef Fun = LLVMGetNamedFunction(M, Name);
1138     if (!Fun)
1139       report_fatal_error("Function must have been declared already");
1140
1141     if (LLVMHasPersonalityFn(Cur)) {
1142       size_t FNameLen;
1143       const char *FName = LLVMGetValueName2(LLVMGetPersonalityFn(Cur),
1144                                            &FNameLen);
1145       LLVMValueRef P = LLVMGetNamedFunction(M, FName);
1146       if (!P)
1147         report_fatal_error("Could not find personality function");
1148       LLVMSetPersonalityFn(Fun, P);
1149     }
1150
1151     size_t NumMetadataEntries;
1152     auto *AllMetadata = LLVMGlobalCopyAllMetadata(Cur, &NumMetadataEntries);
1153     for (unsigned i = 0; i < NumMetadataEntries; ++i) {
1154       unsigned Kind = LLVMValueMetadataEntriesGetKind(AllMetadata, i);
1155       LLVMMetadataRef MD = LLVMValueMetadataEntriesGetMetadata(AllMetadata, i);
1156       LLVMGlobalSetMetadata(Fun, Kind, MD);
1157     }
1158     LLVMDisposeValueMetadataEntries(AllMetadata);
1159
1160     FunCloner FC(Cur, Fun);
1161     FC.CloneBBs(Cur);
1162
1163     Next = LLVMGetNextFunction(Cur);
1164     if (Next == nullptr) {
1165       if (Cur != End)
1166         report_fatal_error("Last function does not match End");
1167       break;
1168     }
1169
1170     LLVMValueRef Prev = LLVMGetPreviousFunction(Next);
1171     if (Prev != Cur)
1172       report_fatal_error("Next.Previous function is not Current");
1173
1174     Cur = Next;
1175   }
1176
1177 AliasClone:
1178   Begin = LLVMGetFirstGlobalAlias(Src);
1179   End = LLVMGetLastGlobalAlias(Src);
1180   if (!Begin) {
1181     if (End != nullptr)
1182       report_fatal_error("Range has an end but no beginning");
1183     goto GlobalIFuncClone;
1184   }
1185
1186   Cur = Begin;
1187   Next = nullptr;
1188   while (true) {
1189     size_t NameLen;
1190     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1191     LLVMValueRef Alias = LLVMGetNamedGlobalAlias(M, Name, NameLen);
1192     if (!Alias)
1193       report_fatal_error("Global alias must have been declared already");
1194
1195     if (LLVMValueRef Aliasee = LLVMAliasGetAliasee(Cur)) {
1196       LLVMAliasSetAliasee(Alias, clone_constant(Aliasee, M));
1197     }
1198
1199     LLVMSetLinkage(Alias, LLVMGetLinkage(Cur));
1200     LLVMSetUnnamedAddress(Alias, LLVMGetUnnamedAddress(Cur));
1201
1202     Next = LLVMGetNextGlobalAlias(Cur);
1203     if (Next == nullptr) {
1204       if (Cur != End)
1205         report_fatal_error("Last global alias does not match End");
1206       break;
1207     }
1208
1209     LLVMValueRef Prev = LLVMGetPreviousGlobalAlias(Next);
1210     if (Prev != Cur)
1211       report_fatal_error("Next.Previous global alias is not Current");
1212
1213     Cur = Next;
1214   }
1215
1216 GlobalIFuncClone:
1217   Begin = LLVMGetFirstGlobalIFunc(Src);
1218   End = LLVMGetLastGlobalIFunc(Src);
1219   if (!Begin) {
1220     if (End != nullptr)
1221       report_fatal_error("Range has an end but no beginning");
1222     goto NamedMDClone;
1223   }
1224
1225   Cur = Begin;
1226   Next = nullptr;
1227   while (true) {
1228     size_t NameLen;
1229     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1230     LLVMValueRef IFunc = LLVMGetNamedGlobalIFunc(M, Name, NameLen);
1231     if (!IFunc)
1232       report_fatal_error("Global ifunc must have been declared already");
1233
1234     if (LLVMValueRef Resolver = LLVMGetGlobalIFuncResolver(Cur)) {
1235       LLVMSetGlobalIFuncResolver(IFunc, clone_constant(Resolver, M));
1236     }
1237
1238     LLVMSetLinkage(IFunc, LLVMGetLinkage(Cur));
1239     LLVMSetUnnamedAddress(IFunc, LLVMGetUnnamedAddress(Cur));
1240
1241     Next = LLVMGetNextGlobalIFunc(Cur);
1242     if (Next == nullptr) {
1243       if (Cur != End)
1244         report_fatal_error("Last global alias does not match End");
1245       break;
1246     }
1247
1248     LLVMValueRef Prev = LLVMGetPreviousGlobalIFunc(Next);
1249     if (Prev != Cur)
1250       report_fatal_error("Next.Previous global alias is not Current");
1251
1252     Cur = Next;
1253   }
1254
1255 NamedMDClone:
1256   LLVMNamedMDNodeRef BeginMD = LLVMGetFirstNamedMetadata(Src);
1257   LLVMNamedMDNodeRef EndMD = LLVMGetLastNamedMetadata(Src);
1258   if (!BeginMD) {
1259     if (EndMD != nullptr)
1260       report_fatal_error("Range has an end but no beginning");
1261     return;
1262   }
1263
1264   LLVMNamedMDNodeRef CurMD = BeginMD;
1265   LLVMNamedMDNodeRef NextMD = nullptr;
1266   while (true) {
1267     size_t NameLen;
1268     const char *Name = LLVMGetNamedMetadataName(CurMD, &NameLen);
1269     LLVMNamedMDNodeRef NamedMD = LLVMGetNamedMetadata(M, Name, NameLen);
1270     if (!NamedMD)
1271       report_fatal_error("Named MD Node must have been declared already");
1272
1273     unsigned OperandCount = LLVMGetNamedMetadataNumOperands(Src, Name);
1274     LLVMValueRef *OperandBuf = static_cast<LLVMValueRef *>(
1275               safe_malloc(OperandCount * sizeof(LLVMValueRef)));
1276     LLVMGetNamedMetadataOperands(Src, Name, OperandBuf);
1277     for (unsigned i = 0, e = OperandCount; i != e; ++i) {
1278       LLVMAddNamedMetadataOperand(M, Name, OperandBuf[i]);
1279     }
1280     free(OperandBuf);
1281
1282     NextMD = LLVMGetNextNamedMetadata(CurMD);
1283     if (NextMD == nullptr) {
1284       if (CurMD != EndMD)
1285         report_fatal_error("Last Named MD Node does not match End");
1286       break;
1287     }
1288
1289     LLVMNamedMDNodeRef PrevMD = LLVMGetPreviousNamedMetadata(NextMD);
1290     if (PrevMD != CurMD)
1291       report_fatal_error("Next.Previous Named MD Node is not Current");
1292
1293     CurMD = NextMD;
1294   }
1295 }
1296
1297 int llvm_echo(void) {
1298   LLVMEnablePrettyStackTrace();
1299
1300   LLVMModuleRef Src = llvm_load_module(false, true);
1301   size_t SourceFileLen;
1302   const char *SourceFileName = LLVMGetSourceFileName(Src, &SourceFileLen);
1303   size_t ModuleIdentLen;
1304   const char *ModuleName = LLVMGetModuleIdentifier(Src, &ModuleIdentLen);
1305   LLVMContextRef Ctx = LLVMContextCreate();
1306   LLVMModuleRef M = LLVMModuleCreateWithNameInContext(ModuleName, Ctx);
1307
1308   LLVMSetSourceFileName(M, SourceFileName, SourceFileLen);
1309   LLVMSetModuleIdentifier(M, ModuleName, ModuleIdentLen);
1310
1311   LLVMSetTarget(M, LLVMGetTarget(Src));
1312   LLVMSetModuleDataLayout(M, LLVMGetModuleDataLayout(Src));
1313   if (strcmp(LLVMGetDataLayoutStr(M), LLVMGetDataLayoutStr(Src)))
1314     report_fatal_error("Inconsistent DataLayout string representation");
1315
1316   size_t ModuleInlineAsmLen;
1317   const char *ModuleAsm = LLVMGetModuleInlineAsm(Src, &ModuleInlineAsmLen);
1318   LLVMSetModuleInlineAsm2(M, ModuleAsm, ModuleInlineAsmLen);
1319
1320   declare_symbols(Src, M);
1321   clone_symbols(Src, M);
1322   char *Str = LLVMPrintModuleToString(M);
1323   fputs(Str, stdout);
1324
1325   LLVMDisposeMessage(Str);
1326   LLVMDisposeModule(Src);
1327   LLVMDisposeModule(M);
1328   LLVMContextDispose(Ctx);
1329
1330   return 0;
1331 }