tools/llvm-c-test/echo.cpp

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