xref: /llvm-project/llvm/tools/llvm-c-test/echo.cpp (revision eb7d535199d7fc3de763276093b97141a041d3d6) 
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/ErrorHandling.h"
20 #include "llvm-c/Target.h"
21 #include "llvm/ADT/DenseMap.h"
22 #include "llvm/ADT/Hashing.h"
23 #include "llvm/ADT/SmallVector.h"
24 #include "llvm/Support/ErrorHandling.h"
25 
26 #include <stdio.h>
27 #include <stdlib.h>
28 
29 using namespace llvm;
30 
31 // Provide DenseMapInfo for C API opaque types.
32 template<typename T>
33 struct CAPIDenseMap {};
34 
35 // The default DenseMapInfo require to know about pointer alignment.
36 // Because the C API uses opaque pointer types, their alignment is unknown.
37 // As a result, we need to roll out our own implementation.
38 template<typename T>
39 struct CAPIDenseMap<T*> {
40   struct CAPIDenseMapInfo {
41     static inline T* getEmptyKey() {
42       uintptr_t Val = static_cast<uintptr_t>(-1);
43       return reinterpret_cast<T*>(Val);
44     }
45     static inline T* getTombstoneKey() {
46       uintptr_t Val = static_cast<uintptr_t>(-2);
47       return reinterpret_cast<T*>(Val);
48     }
49     static unsigned getHashValue(const T *PtrVal) {
50       return hash_value(PtrVal);
51     }
52     static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
53   };
54 
55   typedef DenseMap<T*, T*, CAPIDenseMapInfo> Map;
56 };
57 
58 typedef CAPIDenseMap<LLVMValueRef>::Map ValueMap;
59 typedef CAPIDenseMap<LLVMBasicBlockRef>::Map BasicBlockMap;
60 
61 struct TypeCloner {
62   LLVMModuleRef M;
63   LLVMContextRef Ctx;
64 
65   TypeCloner(LLVMModuleRef M): M(M), Ctx(LLVMGetModuleContext(M)) {}
66 
67   LLVMTypeRef Clone(LLVMValueRef Src) {
68     return Clone(LLVMTypeOf(Src));
69   }
70 
71   LLVMTypeRef Clone(LLVMTypeRef Src) {
72     LLVMTypeKind Kind = LLVMGetTypeKind(Src);
73     switch (Kind) {
74       case LLVMVoidTypeKind:
75         return LLVMVoidTypeInContext(Ctx);
76       case LLVMHalfTypeKind:
77         return LLVMHalfTypeInContext(Ctx);
78       case LLVMBFloatTypeKind:
79         return LLVMHalfTypeInContext(Ctx);
80       case LLVMFloatTypeKind:
81         return LLVMFloatTypeInContext(Ctx);
82       case LLVMDoubleTypeKind:
83         return LLVMDoubleTypeInContext(Ctx);
84       case LLVMX86_FP80TypeKind:
85         return LLVMX86FP80TypeInContext(Ctx);
86       case LLVMFP128TypeKind:
87         return LLVMFP128TypeInContext(Ctx);
88       case LLVMPPC_FP128TypeKind:
89         return LLVMPPCFP128TypeInContext(Ctx);
90       case LLVMLabelTypeKind:
91         return LLVMLabelTypeInContext(Ctx);
92       case LLVMIntegerTypeKind:
93         return LLVMIntTypeInContext(Ctx, LLVMGetIntTypeWidth(Src));
94       case LLVMFunctionTypeKind: {
95         unsigned ParamCount = LLVMCountParamTypes(Src);
96         LLVMTypeRef* Params = nullptr;
97         if (ParamCount > 0) {
98           Params = static_cast<LLVMTypeRef*>(
99               safe_malloc(ParamCount * sizeof(LLVMTypeRef)));
100           LLVMGetParamTypes(Src, Params);
101           for (unsigned i = 0; i < ParamCount; i++)
102             Params[i] = Clone(Params[i]);
103         }
104 
105         LLVMTypeRef FunTy = LLVMFunctionType(Clone(LLVMGetReturnType(Src)),
106                                              Params, ParamCount,
107                                              LLVMIsFunctionVarArg(Src));
108         if (ParamCount > 0)
109           free(Params);
110         return FunTy;
111       }
112       case LLVMStructTypeKind: {
113         LLVMTypeRef S = nullptr;
114         const char *Name = LLVMGetStructName(Src);
115         if (Name) {
116           S = LLVMGetTypeByName2(Ctx, Name);
117           if (S)
118             return S;
119           S = LLVMStructCreateNamed(Ctx, Name);
120           if (LLVMIsOpaqueStruct(Src))
121             return S;
122         }
123 
124         unsigned EltCount = LLVMCountStructElementTypes(Src);
125         SmallVector<LLVMTypeRef, 8> Elts;
126         for (unsigned i = 0; i < EltCount; i++)
127           Elts.push_back(Clone(LLVMStructGetTypeAtIndex(Src, i)));
128         if (Name)
129           LLVMStructSetBody(S, Elts.data(), EltCount, LLVMIsPackedStruct(Src));
130         else
131           S = LLVMStructTypeInContext(Ctx, Elts.data(), EltCount,
132                                       LLVMIsPackedStruct(Src));
133         return S;
134       }
135       case LLVMArrayTypeKind:
136         return LLVMArrayType2(Clone(LLVMGetElementType(Src)),
137                               LLVMGetArrayLength2(Src));
138       case LLVMPointerTypeKind:
139         if (LLVMPointerTypeIsOpaque(Src))
140           return LLVMPointerTypeInContext(Ctx, LLVMGetPointerAddressSpace(Src));
141         else
142           return LLVMPointerType(Clone(LLVMGetElementType(Src)),
143                                  LLVMGetPointerAddressSpace(Src));
144       case LLVMVectorTypeKind:
145         return LLVMVectorType(
146           Clone(LLVMGetElementType(Src)),
147           LLVMGetVectorSize(Src)
148         );
149       case LLVMScalableVectorTypeKind:
150         return LLVMScalableVectorType(Clone(LLVMGetElementType(Src)),
151                                       LLVMGetVectorSize(Src));
152       case LLVMMetadataTypeKind:
153         return LLVMMetadataTypeInContext(Ctx);
154       case LLVMX86_AMXTypeKind:
155         return LLVMX86AMXTypeInContext(Ctx);
156       case LLVMTokenTypeKind:
157         return LLVMTokenTypeInContext(Ctx);
158       case LLVMTargetExtTypeKind: {
159         const char *Name = LLVMGetTargetExtTypeName(Src);
160         unsigned NumTypeParams = LLVMGetTargetExtTypeNumTypeParams(Src);
161         unsigned NumIntParams = LLVMGetTargetExtTypeNumIntParams(Src);
162 
163         SmallVector<LLVMTypeRef, 4> TypeParams((size_t)NumTypeParams);
164         SmallVector<unsigned, 4> IntParams((size_t)NumIntParams);
165 
166         for (unsigned i = 0; i < TypeParams.size(); i++)
167           TypeParams[i] = Clone(LLVMGetTargetExtTypeTypeParam(Src, i));
168 
169         for (unsigned i = 0; i < IntParams.size(); i++)
170           IntParams[i] = LLVMGetTargetExtTypeIntParam(Src, i);
171 
172         LLVMTypeRef TargetExtTy = LLVMTargetExtTypeInContext(
173             Ctx, Name, TypeParams.data(), TypeParams.size(), IntParams.data(),
174             IntParams.size());
175 
176         return TargetExtTy;
177       }
178     }
179 
180     fprintf(stderr, "%d is not a supported typekind\n", Kind);
181     exit(-1);
182   }
183 };
184 
185 static ValueMap clone_params(LLVMValueRef Src, LLVMValueRef Dst) {
186   unsigned Count = LLVMCountParams(Src);
187   if (Count != LLVMCountParams(Dst))
188     report_fatal_error("Parameter count mismatch");
189 
190   ValueMap VMap;
191   if (Count == 0)
192     return VMap;
193 
194   LLVMValueRef SrcFirst = LLVMGetFirstParam(Src);
195   LLVMValueRef DstFirst = LLVMGetFirstParam(Dst);
196   LLVMValueRef SrcLast = LLVMGetLastParam(Src);
197   LLVMValueRef DstLast = LLVMGetLastParam(Dst);
198 
199   LLVMValueRef SrcCur = SrcFirst;
200   LLVMValueRef DstCur = DstFirst;
201   LLVMValueRef SrcNext = nullptr;
202   LLVMValueRef DstNext = nullptr;
203   while (true) {
204     size_t NameLen;
205     const char *Name = LLVMGetValueName2(SrcCur, &NameLen);
206     LLVMSetValueName2(DstCur, Name, NameLen);
207 
208     VMap[SrcCur] = DstCur;
209 
210     Count--;
211     SrcNext = LLVMGetNextParam(SrcCur);
212     DstNext = LLVMGetNextParam(DstCur);
213     if (SrcNext == nullptr && DstNext == nullptr) {
214       if (SrcCur != SrcLast)
215         report_fatal_error("SrcLast param does not match End");
216       if (DstCur != DstLast)
217         report_fatal_error("DstLast param does not match End");
218       break;
219     }
220 
221     if (SrcNext == nullptr)
222       report_fatal_error("SrcNext was unexpectedly null");
223     if (DstNext == nullptr)
224       report_fatal_error("DstNext was unexpectedly null");
225 
226     LLVMValueRef SrcPrev = LLVMGetPreviousParam(SrcNext);
227     if (SrcPrev != SrcCur)
228       report_fatal_error("SrcNext.Previous param is not Current");
229 
230     LLVMValueRef DstPrev = LLVMGetPreviousParam(DstNext);
231     if (DstPrev != DstCur)
232       report_fatal_error("DstNext.Previous param is not Current");
233 
234     SrcCur = SrcNext;
235     DstCur = DstNext;
236   }
237 
238   if (Count != 0)
239     report_fatal_error("Parameter count does not match iteration");
240 
241   return VMap;
242 }
243 
244 static void check_value_kind(LLVMValueRef V, LLVMValueKind K) {
245   if (LLVMGetValueKind(V) != K)
246     report_fatal_error("LLVMGetValueKind returned incorrect type");
247 }
248 
249 static LLVMValueRef clone_constant_impl(LLVMValueRef Cst, LLVMModuleRef M);
250 
251 static LLVMValueRef clone_constant(LLVMValueRef Cst, LLVMModuleRef M) {
252   LLVMValueRef Ret = clone_constant_impl(Cst, M);
253   check_value_kind(Ret, LLVMGetValueKind(Cst));
254   return Ret;
255 }
256 
257 static LLVMValueRef clone_constant_impl(LLVMValueRef Cst, LLVMModuleRef M) {
258   if (!LLVMIsAConstant(Cst))
259     report_fatal_error("Expected a constant");
260 
261   // Maybe it is a symbol
262   if (LLVMIsAGlobalValue(Cst)) {
263     size_t NameLen;
264     const char *Name = LLVMGetValueName2(Cst, &NameLen);
265 
266     // Try function
267     if (LLVMIsAFunction(Cst)) {
268       check_value_kind(Cst, LLVMFunctionValueKind);
269 
270       LLVMValueRef Dst = nullptr;
271       // Try an intrinsic
272       unsigned ID = LLVMGetIntrinsicID(Cst);
273       if (ID > 0 && !LLVMIntrinsicIsOverloaded(ID)) {
274         Dst = LLVMGetIntrinsicDeclaration(M, ID, nullptr, 0);
275       } else {
276         // Try a normal function
277         Dst = LLVMGetNamedFunction(M, Name);
278       }
279 
280       if (Dst)
281         return Dst;
282       report_fatal_error("Could not find function");
283     }
284 
285     // Try global variable
286     if (LLVMIsAGlobalVariable(Cst)) {
287       check_value_kind(Cst, LLVMGlobalVariableValueKind);
288       LLVMValueRef Dst = LLVMGetNamedGlobal(M, Name);
289       if (Dst)
290         return Dst;
291       report_fatal_error("Could not find variable");
292     }
293 
294     // Try global alias
295     if (LLVMIsAGlobalAlias(Cst)) {
296       check_value_kind(Cst, LLVMGlobalAliasValueKind);
297       LLVMValueRef Dst = LLVMGetNamedGlobalAlias(M, Name, NameLen);
298       if (Dst)
299         return Dst;
300       report_fatal_error("Could not find alias");
301     }
302 
303     fprintf(stderr, "Could not find @%s\n", Name);
304     exit(-1);
305   }
306 
307   // Try integer literal
308   if (LLVMIsAConstantInt(Cst)) {
309     check_value_kind(Cst, LLVMConstantIntValueKind);
310     return LLVMConstInt(TypeCloner(M).Clone(Cst),
311                         LLVMConstIntGetZExtValue(Cst), false);
312   }
313 
314   // Try zeroinitializer
315   if (LLVMIsAConstantAggregateZero(Cst)) {
316     check_value_kind(Cst, LLVMConstantAggregateZeroValueKind);
317     return LLVMConstNull(TypeCloner(M).Clone(Cst));
318   }
319 
320   // Try constant array or constant data array
321   if (LLVMIsAConstantArray(Cst) || LLVMIsAConstantDataArray(Cst)) {
322     check_value_kind(Cst, LLVMIsAConstantArray(Cst)
323                               ? LLVMConstantArrayValueKind
324                               : LLVMConstantDataArrayValueKind);
325     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
326     uint64_t EltCount = LLVMGetArrayLength2(Ty);
327     SmallVector<LLVMValueRef, 8> Elts;
328     for (uint64_t i = 0; i < EltCount; i++)
329       Elts.push_back(clone_constant(LLVMGetAggregateElement(Cst, i), M));
330     return LLVMConstArray(LLVMGetElementType(Ty), Elts.data(), EltCount);
331   }
332 
333   // Try constant struct
334   if (LLVMIsAConstantStruct(Cst)) {
335     check_value_kind(Cst, LLVMConstantStructValueKind);
336     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
337     unsigned EltCount = LLVMCountStructElementTypes(Ty);
338     SmallVector<LLVMValueRef, 8> Elts;
339     for (unsigned i = 0; i < EltCount; i++)
340       Elts.push_back(clone_constant(LLVMGetOperand(Cst, i), M));
341     if (LLVMGetStructName(Ty))
342       return LLVMConstNamedStruct(Ty, Elts.data(), EltCount);
343     return LLVMConstStructInContext(LLVMGetModuleContext(M), Elts.data(),
344                                     EltCount, LLVMIsPackedStruct(Ty));
345   }
346 
347   // Try ConstantPointerNull
348   if (LLVMIsAConstantPointerNull(Cst)) {
349     check_value_kind(Cst, LLVMConstantPointerNullValueKind);
350     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
351     return LLVMConstNull(Ty);
352   }
353 
354   // Try undef
355   if (LLVMIsUndef(Cst)) {
356     check_value_kind(Cst, LLVMUndefValueValueKind);
357     return LLVMGetUndef(TypeCloner(M).Clone(Cst));
358   }
359 
360   // Try poison
361   if (LLVMIsPoison(Cst)) {
362     check_value_kind(Cst, LLVMPoisonValueValueKind);
363     return LLVMGetPoison(TypeCloner(M).Clone(Cst));
364   }
365 
366   // Try null
367   if (LLVMIsNull(Cst)) {
368     check_value_kind(Cst, LLVMConstantTokenNoneValueKind);
369     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
370     return LLVMConstNull(Ty);
371   }
372 
373   // Try float literal
374   if (LLVMIsAConstantFP(Cst)) {
375     check_value_kind(Cst, LLVMConstantFPValueKind);
376     report_fatal_error("ConstantFP is not supported");
377   }
378 
379   // Try ConstantVector or ConstantDataVector
380   if (LLVMIsAConstantVector(Cst) || LLVMIsAConstantDataVector(Cst)) {
381     check_value_kind(Cst, LLVMIsAConstantVector(Cst)
382                               ? LLVMConstantVectorValueKind
383                               : LLVMConstantDataVectorValueKind);
384     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
385     unsigned EltCount = LLVMGetVectorSize(Ty);
386     SmallVector<LLVMValueRef, 8> Elts;
387     for (unsigned i = 0; i < EltCount; i++)
388       Elts.push_back(clone_constant(LLVMGetAggregateElement(Cst, i), M));
389     return LLVMConstVector(Elts.data(), EltCount);
390   }
391 
392   if (LLVMIsAConstantPtrAuth(Cst)) {
393     LLVMValueRef Ptr = clone_constant(LLVMGetConstantPtrAuthPointer(Cst), M);
394     LLVMValueRef Key = clone_constant(LLVMGetConstantPtrAuthKey(Cst), M);
395     LLVMValueRef Disc =
396         clone_constant(LLVMGetConstantPtrAuthDiscriminator(Cst), M);
397     LLVMValueRef AddrDisc =
398         clone_constant(LLVMGetConstantPtrAuthAddrDiscriminator(Cst), M);
399     return LLVMConstantPtrAuth(Ptr, Key, Disc, AddrDisc);
400   }
401 
402   // At this point, if it's not a constant expression, it's a kind of constant
403   // which is not supported
404   if (!LLVMIsAConstantExpr(Cst))
405     report_fatal_error("Unsupported constant kind");
406 
407   // At this point, it must be a constant expression
408   check_value_kind(Cst, LLVMConstantExprValueKind);
409 
410   LLVMOpcode Op = LLVMGetConstOpcode(Cst);
411   switch(Op) {
412     case LLVMBitCast:
413       return LLVMConstBitCast(clone_constant(LLVMGetOperand(Cst, 0), M),
414                               TypeCloner(M).Clone(Cst));
415     case LLVMGetElementPtr: {
416       LLVMTypeRef ElemTy =
417           TypeCloner(M).Clone(LLVMGetGEPSourceElementType(Cst));
418       LLVMValueRef Ptr = clone_constant(LLVMGetOperand(Cst, 0), M);
419       int NumIdx = LLVMGetNumIndices(Cst);
420       SmallVector<LLVMValueRef, 8> Idx;
421       for (int i = 1; i <= NumIdx; i++)
422         Idx.push_back(clone_constant(LLVMGetOperand(Cst, i), M));
423 
424       return LLVMConstGEPWithNoWrapFlags(ElemTy, Ptr, Idx.data(), NumIdx,
425                                          LLVMGEPGetNoWrapFlags(Cst));
426     }
427     default:
428       fprintf(stderr, "%d is not a supported opcode for constant expressions\n",
429               Op);
430       exit(-1);
431   }
432 }
433 
434 static LLVMValueRef clone_inline_asm(LLVMValueRef Asm, LLVMModuleRef M) {
435 
436   if (!LLVMIsAInlineAsm(Asm))
437       report_fatal_error("Expected inline assembly");
438 
439   size_t AsmStringSize = 0;
440   const char *AsmString = LLVMGetInlineAsmAsmString(Asm, &AsmStringSize);
441 
442   size_t ConstraintStringSize = 0;
443   const char *ConstraintString =
444       LLVMGetInlineAsmConstraintString(Asm, &ConstraintStringSize);
445 
446   LLVMInlineAsmDialect AsmDialect = LLVMGetInlineAsmDialect(Asm);
447 
448   LLVMTypeRef AsmFunctionType = LLVMGetInlineAsmFunctionType(Asm);
449 
450   LLVMBool HasSideEffects = LLVMGetInlineAsmHasSideEffects(Asm);
451   LLVMBool NeedsAlignStack = LLVMGetInlineAsmNeedsAlignedStack(Asm);
452   LLVMBool CanUnwind = LLVMGetInlineAsmCanUnwind(Asm);
453 
454   return LLVMGetInlineAsm(AsmFunctionType, AsmString, AsmStringSize,
455                           ConstraintString, ConstraintStringSize,
456                           HasSideEffects, NeedsAlignStack, AsmDialect,
457                           CanUnwind);
458 }
459 
460 struct FunCloner {
461   LLVMValueRef Fun;
462   LLVMModuleRef M;
463 
464   ValueMap VMap;
465   BasicBlockMap BBMap;
466 
467   FunCloner(LLVMValueRef Src, LLVMValueRef Dst): Fun(Dst),
468     M(LLVMGetGlobalParent(Fun)), VMap(clone_params(Src, Dst)) {}
469 
470   LLVMTypeRef CloneType(LLVMTypeRef Src) {
471     return TypeCloner(M).Clone(Src);
472   }
473 
474   LLVMTypeRef CloneType(LLVMValueRef Src) {
475     return TypeCloner(M).Clone(Src);
476   }
477 
478   // Try to clone everything in the llvm::Value hierarchy.
479   LLVMValueRef CloneValue(LLVMValueRef Src) {
480     // First, the value may be constant.
481     if (LLVMIsAConstant(Src))
482       return clone_constant(Src, M);
483 
484     // Function argument should always be in the map already.
485     auto i = VMap.find(Src);
486     if (i != VMap.end())
487       return i->second;
488 
489     // Inline assembly is a Value, but not an Instruction
490     if (LLVMIsAInlineAsm(Src))
491       return clone_inline_asm(Src, M);
492 
493     if (!LLVMIsAInstruction(Src))
494       report_fatal_error("Expected an instruction");
495 
496     auto Ctx = LLVMGetModuleContext(M);
497     auto Builder = LLVMCreateBuilderInContext(Ctx);
498     auto BB = DeclareBB(LLVMGetInstructionParent(Src));
499     LLVMPositionBuilderAtEnd(Builder, BB);
500     auto Dst = CloneInstruction(Src, Builder);
501     LLVMDisposeBuilder(Builder);
502     return Dst;
503   }
504 
505   void CloneAttrs(LLVMValueRef Src, LLVMValueRef Dst) {
506     auto Ctx = LLVMGetModuleContext(M);
507     int ArgCount = LLVMGetNumArgOperands(Src);
508     for (int i = LLVMAttributeReturnIndex; i <= ArgCount; i++) {
509       for (unsigned k = 0, e = LLVMGetLastEnumAttributeKind(); k < e; ++k) {
510         if (auto SrcA = LLVMGetCallSiteEnumAttribute(Src, i, k)) {
511           auto Val = LLVMGetEnumAttributeValue(SrcA);
512           auto A = LLVMCreateEnumAttribute(Ctx, k, Val);
513           LLVMAddCallSiteAttribute(Dst, i, A);
514         }
515       }
516     }
517   }
518 
519   LLVMValueRef CloneInstruction(LLVMValueRef Src, LLVMBuilderRef Builder) {
520     check_value_kind(Src, LLVMInstructionValueKind);
521     if (!LLVMIsAInstruction(Src))
522       report_fatal_error("Expected an instruction");
523     LLVMContextRef Ctx = LLVMGetTypeContext(LLVMTypeOf(Src));
524 
525     size_t NameLen;
526     const char *Name = LLVMGetValueName2(Src, &NameLen);
527 
528     // Check if this is something we already computed.
529     {
530       auto i = VMap.find(Src);
531       if (i != VMap.end()) {
532         // If we have a hit, it means we already generated the instruction
533         // as a dependency to something else. We need to make sure
534         // it is ordered properly.
535         auto I = i->second;
536         LLVMInstructionRemoveFromParent(I);
537         LLVMInsertIntoBuilderWithName(Builder, I, Name);
538         return I;
539       }
540     }
541 
542     // We tried everything, it must be an instruction
543     // that hasn't been generated already.
544     LLVMValueRef Dst = nullptr;
545 
546     LLVMOpcode Op = LLVMGetInstructionOpcode(Src);
547     switch(Op) {
548       case LLVMRet: {
549         int OpCount = LLVMGetNumOperands(Src);
550         if (OpCount == 0)
551           Dst = LLVMBuildRetVoid(Builder);
552         else
553           Dst = LLVMBuildRet(Builder, CloneValue(LLVMGetOperand(Src, 0)));
554         break;
555       }
556       case LLVMBr: {
557         if (!LLVMIsConditional(Src)) {
558           LLVMValueRef SrcOp = LLVMGetOperand(Src, 0);
559           LLVMBasicBlockRef SrcBB = LLVMValueAsBasicBlock(SrcOp);
560           Dst = LLVMBuildBr(Builder, DeclareBB(SrcBB));
561           break;
562         }
563 
564         LLVMValueRef Cond = LLVMGetCondition(Src);
565         LLVMValueRef Else = LLVMGetOperand(Src, 1);
566         LLVMBasicBlockRef ElseBB = DeclareBB(LLVMValueAsBasicBlock(Else));
567         LLVMValueRef Then = LLVMGetOperand(Src, 2);
568         LLVMBasicBlockRef ThenBB = DeclareBB(LLVMValueAsBasicBlock(Then));
569         Dst = LLVMBuildCondBr(Builder, CloneValue(Cond), ThenBB, ElseBB);
570         break;
571       }
572       case LLVMSwitch:
573       case LLVMIndirectBr:
574         break;
575       case LLVMInvoke: {
576         SmallVector<LLVMValueRef, 8> Args;
577         SmallVector<LLVMOperandBundleRef, 8> Bundles;
578         unsigned ArgCount = LLVMGetNumArgOperands(Src);
579         for (unsigned i = 0; i < ArgCount; ++i)
580           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
581         unsigned BundleCount = LLVMGetNumOperandBundles(Src);
582         for (unsigned i = 0; i < BundleCount; ++i) {
583           auto Bundle = LLVMGetOperandBundleAtIndex(Src, i);
584           Bundles.push_back(CloneOB(Bundle));
585           LLVMDisposeOperandBundle(Bundle);
586         }
587         LLVMTypeRef FnTy = CloneType(LLVMGetCalledFunctionType(Src));
588         LLVMValueRef Fn = CloneValue(LLVMGetCalledValue(Src));
589         LLVMBasicBlockRef Then = DeclareBB(LLVMGetNormalDest(Src));
590         LLVMBasicBlockRef Unwind = DeclareBB(LLVMGetUnwindDest(Src));
591         Dst = LLVMBuildInvokeWithOperandBundles(
592             Builder, FnTy, Fn, Args.data(), ArgCount, Then, Unwind,
593             Bundles.data(), Bundles.size(), Name);
594         CloneAttrs(Src, Dst);
595         for (auto Bundle : Bundles)
596           LLVMDisposeOperandBundle(Bundle);
597         break;
598       }
599       case LLVMCallBr: {
600         LLVMTypeRef FnTy = CloneType(LLVMGetCalledFunctionType(Src));
601         LLVMValueRef Fn = CloneValue(LLVMGetCalledValue(Src));
602 
603         LLVMBasicBlockRef DefaultDest =
604             DeclareBB(LLVMGetCallBrDefaultDest(Src));
605 
606         // Clone indirect destinations
607         SmallVector<LLVMBasicBlockRef, 8> IndirectDests;
608         unsigned IndirectDestCount = LLVMGetCallBrNumIndirectDests(Src);
609         for (unsigned i = 0; i < IndirectDestCount; ++i)
610           IndirectDests.push_back(DeclareBB(LLVMGetCallBrIndirectDest(Src, i)));
611 
612         // Clone input arguments
613         SmallVector<LLVMValueRef, 8> Args;
614         unsigned ArgCount = LLVMGetNumArgOperands(Src);
615         for (unsigned i = 0; i < ArgCount; ++i)
616           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
617 
618         // Clone operand bundles
619         SmallVector<LLVMOperandBundleRef, 8> Bundles;
620         unsigned BundleCount = LLVMGetNumOperandBundles(Src);
621         for (unsigned i = 0; i < BundleCount; ++i) {
622           auto Bundle = LLVMGetOperandBundleAtIndex(Src, i);
623           Bundles.push_back(CloneOB(Bundle));
624           LLVMDisposeOperandBundle(Bundle);
625         }
626 
627         Dst = LLVMBuildCallBr(Builder, FnTy, Fn, DefaultDest,
628                               IndirectDests.data(), IndirectDests.size(),
629                               Args.data(), Args.size(), Bundles.data(),
630                               Bundles.size(), Name);
631 
632         CloneAttrs(Src, Dst);
633 
634         for (auto Bundle : Bundles)
635           LLVMDisposeOperandBundle(Bundle);
636 
637         break;
638       }
639       case LLVMUnreachable:
640         Dst = LLVMBuildUnreachable(Builder);
641         break;
642       case LLVMAdd: {
643         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
644         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
645         LLVMBool NUW = LLVMGetNUW(Src);
646         LLVMBool NSW = LLVMGetNSW(Src);
647         Dst = LLVMBuildAdd(Builder, LHS, RHS, Name);
648         LLVMSetNUW(Dst, NUW);
649         LLVMSetNSW(Dst, NSW);
650         break;
651       }
652       case LLVMSub: {
653         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
654         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
655         LLVMBool NUW = LLVMGetNUW(Src);
656         LLVMBool NSW = LLVMGetNSW(Src);
657         Dst = LLVMBuildSub(Builder, LHS, RHS, Name);
658         LLVMSetNUW(Dst, NUW);
659         LLVMSetNSW(Dst, NSW);
660         break;
661       }
662       case LLVMMul: {
663         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
664         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
665         LLVMBool NUW = LLVMGetNUW(Src);
666         LLVMBool NSW = LLVMGetNSW(Src);
667         Dst = LLVMBuildMul(Builder, LHS, RHS, Name);
668         LLVMSetNUW(Dst, NUW);
669         LLVMSetNSW(Dst, NSW);
670         break;
671       }
672       case LLVMUDiv: {
673         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
674         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
675         LLVMBool IsExact = LLVMGetExact(Src);
676         Dst = LLVMBuildUDiv(Builder, LHS, RHS, Name);
677         LLVMSetExact(Dst, IsExact);
678         break;
679       }
680       case LLVMSDiv: {
681         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
682         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
683         LLVMBool IsExact = LLVMGetExact(Src);
684         Dst = LLVMBuildSDiv(Builder, LHS, RHS, Name);
685         LLVMSetExact(Dst, IsExact);
686         break;
687       }
688       case LLVMURem: {
689         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
690         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
691         Dst = LLVMBuildURem(Builder, LHS, RHS, Name);
692         break;
693       }
694       case LLVMSRem: {
695         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
696         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
697         Dst = LLVMBuildSRem(Builder, LHS, RHS, Name);
698         break;
699       }
700       case LLVMShl: {
701         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
702         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
703         LLVMBool NUW = LLVMGetNUW(Src);
704         LLVMBool NSW = LLVMGetNSW(Src);
705         Dst = LLVMBuildShl(Builder, LHS, RHS, Name);
706         LLVMSetNUW(Dst, NUW);
707         LLVMSetNSW(Dst, NSW);
708         break;
709       }
710       case LLVMLShr: {
711         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
712         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
713         LLVMBool IsExact = LLVMGetExact(Src);
714         Dst = LLVMBuildLShr(Builder, LHS, RHS, Name);
715         LLVMSetExact(Dst, IsExact);
716         break;
717       }
718       case LLVMAShr: {
719         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
720         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
721         LLVMBool IsExact = LLVMGetExact(Src);
722         Dst = LLVMBuildAShr(Builder, LHS, RHS, Name);
723         LLVMSetExact(Dst, IsExact);
724         break;
725       }
726       case LLVMAnd: {
727         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
728         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
729         Dst = LLVMBuildAnd(Builder, LHS, RHS, Name);
730         break;
731       }
732       case LLVMOr: {
733         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
734         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
735         LLVMBool IsDisjoint = LLVMGetIsDisjoint(Src);
736         Dst = LLVMBuildOr(Builder, LHS, RHS, Name);
737         LLVMSetIsDisjoint(Dst, IsDisjoint);
738         break;
739       }
740       case LLVMXor: {
741         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
742         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
743         Dst = LLVMBuildXor(Builder, LHS, RHS, Name);
744         break;
745       }
746       case LLVMAlloca: {
747         LLVMTypeRef Ty = CloneType(LLVMGetAllocatedType(Src));
748         Dst = LLVMBuildAlloca(Builder, Ty, Name);
749         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
750         break;
751       }
752       case LLVMLoad: {
753         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
754         Dst = LLVMBuildLoad2(Builder, CloneType(Src), Ptr, Name);
755         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
756         LLVMSetOrdering(Dst, LLVMGetOrdering(Src));
757         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
758         if (LLVMIsAtomic(Src))
759           LLVMSetAtomicSyncScopeID(Dst, LLVMGetAtomicSyncScopeID(Src));
760         break;
761       }
762       case LLVMStore: {
763         LLVMValueRef Val = CloneValue(LLVMGetOperand(Src, 0));
764         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 1));
765         Dst = LLVMBuildStore(Builder, Val, Ptr);
766         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
767         LLVMSetOrdering(Dst, LLVMGetOrdering(Src));
768         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
769         if (LLVMIsAtomic(Src))
770           LLVMSetAtomicSyncScopeID(Dst, LLVMGetAtomicSyncScopeID(Src));
771         break;
772       }
773       case LLVMGetElementPtr: {
774         LLVMTypeRef ElemTy = CloneType(LLVMGetGEPSourceElementType(Src));
775         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
776         SmallVector<LLVMValueRef, 8> Idx;
777         int NumIdx = LLVMGetNumIndices(Src);
778         for (int i = 1; i <= NumIdx; i++)
779           Idx.push_back(CloneValue(LLVMGetOperand(Src, i)));
780 
781         Dst = LLVMBuildGEPWithNoWrapFlags(Builder, ElemTy, Ptr, Idx.data(),
782                                           NumIdx, Name,
783                                           LLVMGEPGetNoWrapFlags(Src));
784         break;
785       }
786       case LLVMAtomicRMW: {
787         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
788         LLVMValueRef Val = CloneValue(LLVMGetOperand(Src, 1));
789         LLVMAtomicRMWBinOp BinOp = LLVMGetAtomicRMWBinOp(Src);
790         LLVMAtomicOrdering Ord = LLVMGetOrdering(Src);
791         Dst = LLVMBuildAtomicRMWSyncScope(Builder, BinOp, Ptr, Val, Ord,
792                                           LLVMGetAtomicSyncScopeID(Src));
793         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
794         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
795         LLVMSetValueName2(Dst, Name, NameLen);
796         break;
797       }
798       case LLVMAtomicCmpXchg: {
799         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
800         LLVMValueRef Cmp = CloneValue(LLVMGetOperand(Src, 1));
801         LLVMValueRef New = CloneValue(LLVMGetOperand(Src, 2));
802         LLVMAtomicOrdering Succ = LLVMGetCmpXchgSuccessOrdering(Src);
803         LLVMAtomicOrdering Fail = LLVMGetCmpXchgFailureOrdering(Src);
804         Dst = LLVMBuildAtomicCmpXchgSyncScope(
805             Builder, Ptr, Cmp, New, Succ, Fail, LLVMGetAtomicSyncScopeID(Src));
806         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
807         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
808         LLVMSetWeak(Dst, LLVMGetWeak(Src));
809         LLVMSetValueName2(Dst, Name, NameLen);
810         break;
811       }
812       case LLVMBitCast: {
813         LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 0));
814         Dst = LLVMBuildBitCast(Builder, V, CloneType(Src), Name);
815         break;
816       }
817       case LLVMICmp: {
818         LLVMIntPredicate Pred = LLVMGetICmpPredicate(Src);
819         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
820         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
821         Dst = LLVMBuildICmp(Builder, Pred, LHS, RHS, Name);
822         break;
823       }
824       case LLVMPHI: {
825         // We need to aggressively set things here because of loops.
826         VMap[Src] = Dst = LLVMBuildPhi(Builder, CloneType(Src), Name);
827 
828         SmallVector<LLVMValueRef, 8> Values;
829         SmallVector<LLVMBasicBlockRef, 8> Blocks;
830 
831         unsigned IncomingCount = LLVMCountIncoming(Src);
832         for (unsigned i = 0; i < IncomingCount; ++i) {
833           Blocks.push_back(DeclareBB(LLVMGetIncomingBlock(Src, i)));
834           Values.push_back(CloneValue(LLVMGetIncomingValue(Src, i)));
835         }
836 
837         LLVMAddIncoming(Dst, Values.data(), Blocks.data(), IncomingCount);
838         // Copy fast math flags here since we return early
839         if (LLVMCanValueUseFastMathFlags(Src))
840           LLVMSetFastMathFlags(Dst, LLVMGetFastMathFlags(Src));
841         return Dst;
842       }
843       case LLVMSelect: {
844         LLVMValueRef If = CloneValue(LLVMGetOperand(Src, 0));
845         LLVMValueRef Then = CloneValue(LLVMGetOperand(Src, 1));
846         LLVMValueRef Else = CloneValue(LLVMGetOperand(Src, 2));
847         Dst = LLVMBuildSelect(Builder, If, Then, Else, Name);
848         break;
849       }
850       case LLVMCall: {
851         SmallVector<LLVMValueRef, 8> Args;
852         SmallVector<LLVMOperandBundleRef, 8> Bundles;
853         unsigned ArgCount = LLVMGetNumArgOperands(Src);
854         for (unsigned i = 0; i < ArgCount; ++i)
855           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
856         unsigned BundleCount = LLVMGetNumOperandBundles(Src);
857         for (unsigned i = 0; i < BundleCount; ++i) {
858           auto Bundle = LLVMGetOperandBundleAtIndex(Src, i);
859           Bundles.push_back(CloneOB(Bundle));
860           LLVMDisposeOperandBundle(Bundle);
861         }
862         LLVMTypeRef FnTy = CloneType(LLVMGetCalledFunctionType(Src));
863         LLVMValueRef Fn = CloneValue(LLVMGetCalledValue(Src));
864         Dst = LLVMBuildCallWithOperandBundles(Builder, FnTy, Fn, Args.data(),
865                                               ArgCount, Bundles.data(),
866                                               Bundles.size(), Name);
867         LLVMSetTailCallKind(Dst, LLVMGetTailCallKind(Src));
868         CloneAttrs(Src, Dst);
869         for (auto Bundle : Bundles)
870           LLVMDisposeOperandBundle(Bundle);
871         break;
872       }
873       case LLVMResume: {
874         Dst = LLVMBuildResume(Builder, CloneValue(LLVMGetOperand(Src, 0)));
875         break;
876       }
877       case LLVMLandingPad: {
878         // The landing pad API is a bit screwed up for historical reasons.
879         Dst = LLVMBuildLandingPad(Builder, CloneType(Src), nullptr, 0, Name);
880         unsigned NumClauses = LLVMGetNumClauses(Src);
881         for (unsigned i = 0; i < NumClauses; ++i)
882           LLVMAddClause(Dst, CloneValue(LLVMGetClause(Src, i)));
883         LLVMSetCleanup(Dst, LLVMIsCleanup(Src));
884         break;
885       }
886       case LLVMCleanupRet: {
887         LLVMValueRef CatchPad = CloneValue(LLVMGetOperand(Src, 0));
888         LLVMBasicBlockRef Unwind = nullptr;
889         if (LLVMBasicBlockRef UDest = LLVMGetUnwindDest(Src))
890           Unwind = DeclareBB(UDest);
891         Dst = LLVMBuildCleanupRet(Builder, CatchPad, Unwind);
892         break;
893       }
894       case LLVMCatchRet: {
895         LLVMValueRef CatchPad = CloneValue(LLVMGetOperand(Src, 0));
896         LLVMBasicBlockRef SuccBB = DeclareBB(LLVMGetSuccessor(Src, 0));
897         Dst = LLVMBuildCatchRet(Builder, CatchPad, SuccBB);
898         break;
899       }
900       case LLVMCatchPad: {
901         LLVMValueRef ParentPad = CloneValue(LLVMGetParentCatchSwitch(Src));
902         SmallVector<LLVMValueRef, 8> Args;
903         int ArgCount = LLVMGetNumArgOperands(Src);
904         for (int i = 0; i < ArgCount; i++)
905           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
906         Dst = LLVMBuildCatchPad(Builder, ParentPad,
907                                 Args.data(), ArgCount, Name);
908         break;
909       }
910       case LLVMCleanupPad: {
911         LLVMValueRef ParentPad = CloneValue(LLVMGetOperand(Src, 0));
912         SmallVector<LLVMValueRef, 8> Args;
913         int ArgCount = LLVMGetNumArgOperands(Src);
914         for (int i = 0; i < ArgCount; i++)
915           Args.push_back(CloneValue(LLVMGetArgOperand(Src, i)));
916         Dst = LLVMBuildCleanupPad(Builder, ParentPad,
917                                   Args.data(), ArgCount, Name);
918         break;
919       }
920       case LLVMCatchSwitch: {
921         LLVMValueRef ParentPad = CloneValue(LLVMGetOperand(Src, 0));
922         LLVMBasicBlockRef UnwindBB = nullptr;
923         if (LLVMBasicBlockRef UDest = LLVMGetUnwindDest(Src)) {
924           UnwindBB = DeclareBB(UDest);
925         }
926         unsigned NumHandlers = LLVMGetNumHandlers(Src);
927         Dst = LLVMBuildCatchSwitch(Builder, ParentPad, UnwindBB, NumHandlers, Name);
928         if (NumHandlers > 0) {
929           LLVMBasicBlockRef *Handlers = static_cast<LLVMBasicBlockRef*>(
930                        safe_malloc(NumHandlers * sizeof(LLVMBasicBlockRef)));
931           LLVMGetHandlers(Src, Handlers);
932           for (unsigned i = 0; i < NumHandlers; i++)
933             LLVMAddHandler(Dst, DeclareBB(Handlers[i]));
934           free(Handlers);
935         }
936         break;
937       }
938       case LLVMExtractValue: {
939         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
940         if (LLVMGetNumIndices(Src) > 1)
941           report_fatal_error("ExtractValue: Expected only one index");
942         else if (LLVMGetNumIndices(Src) < 1)
943           report_fatal_error("ExtractValue: Expected an index");
944         auto I = LLVMGetIndices(Src)[0];
945         Dst = LLVMBuildExtractValue(Builder, Agg, I, Name);
946         break;
947       }
948       case LLVMInsertValue: {
949         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
950         LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 1));
951         if (LLVMGetNumIndices(Src) > 1)
952           report_fatal_error("InsertValue: Expected only one index");
953         else if (LLVMGetNumIndices(Src) < 1)
954           report_fatal_error("InsertValue: Expected an index");
955         auto I = LLVMGetIndices(Src)[0];
956         Dst = LLVMBuildInsertValue(Builder, Agg, V, I, Name);
957         break;
958       }
959       case LLVMExtractElement: {
960         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
961         LLVMValueRef Index = CloneValue(LLVMGetOperand(Src, 1));
962         Dst = LLVMBuildExtractElement(Builder, Agg, Index, Name);
963         break;
964       }
965       case LLVMInsertElement: {
966         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
967         LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 1));
968         LLVMValueRef Index = CloneValue(LLVMGetOperand(Src, 2));
969         Dst = LLVMBuildInsertElement(Builder, Agg, V, Index, Name);
970         break;
971       }
972       case LLVMShuffleVector: {
973         LLVMValueRef Agg0 = CloneValue(LLVMGetOperand(Src, 0));
974         LLVMValueRef Agg1 = CloneValue(LLVMGetOperand(Src, 1));
975         SmallVector<LLVMValueRef, 8> MaskElts;
976         unsigned NumMaskElts = LLVMGetNumMaskElements(Src);
977         for (unsigned i = 0; i < NumMaskElts; i++) {
978           int Val = LLVMGetMaskValue(Src, i);
979           if (Val == LLVMGetUndefMaskElem()) {
980             MaskElts.push_back(LLVMGetUndef(LLVMInt64Type()));
981           } else {
982             MaskElts.push_back(LLVMConstInt(LLVMInt64Type(), Val, true));
983           }
984         }
985         LLVMValueRef Mask = LLVMConstVector(MaskElts.data(), NumMaskElts);
986         Dst = LLVMBuildShuffleVector(Builder, Agg0, Agg1, Mask, Name);
987         break;
988       }
989       case LLVMFreeze: {
990         LLVMValueRef Arg = CloneValue(LLVMGetOperand(Src, 0));
991         Dst = LLVMBuildFreeze(Builder, Arg, Name);
992         break;
993       }
994       case LLVMFence: {
995         LLVMAtomicOrdering Ordering = LLVMGetOrdering(Src);
996         Dst = LLVMBuildFenceSyncScope(Builder, Ordering,
997                                       LLVMGetAtomicSyncScopeID(Src), Name);
998         break;
999       }
1000       case LLVMZExt: {
1001         LLVMValueRef Val = CloneValue(LLVMGetOperand(Src, 0));
1002         LLVMTypeRef DestTy = CloneType(LLVMTypeOf(Src));
1003         LLVMBool NNeg = LLVMGetNNeg(Src);
1004         Dst = LLVMBuildZExt(Builder, Val, DestTy, Name);
1005         LLVMSetNNeg(Dst, NNeg);
1006         break;
1007       }
1008       case LLVMFAdd: {
1009         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
1010         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
1011         Dst = LLVMBuildFAdd(Builder, LHS, RHS, Name);
1012         break;
1013       }
1014       case LLVMFSub: {
1015         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
1016         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
1017         Dst = LLVMBuildFSub(Builder, LHS, RHS, Name);
1018         break;
1019       }
1020       case LLVMFMul: {
1021         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
1022         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
1023         Dst = LLVMBuildFMul(Builder, LHS, RHS, Name);
1024         break;
1025       }
1026       case LLVMFDiv: {
1027         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
1028         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
1029         Dst = LLVMBuildFDiv(Builder, LHS, RHS, Name);
1030         break;
1031       }
1032       case LLVMFRem: {
1033         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
1034         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
1035         Dst = LLVMBuildFRem(Builder, LHS, RHS, Name);
1036         break;
1037       }
1038       case LLVMFNeg: {
1039         LLVMValueRef Val = CloneValue(LLVMGetOperand(Src, 0));
1040         Dst = LLVMBuildFNeg(Builder, Val, Name);
1041         break;
1042       }
1043       case LLVMFCmp: {
1044         LLVMRealPredicate Pred = LLVMGetFCmpPredicate(Src);
1045         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
1046         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
1047         Dst = LLVMBuildFCmp(Builder, Pred, LHS, RHS, Name);
1048         break;
1049       }
1050       default:
1051         break;
1052     }
1053 
1054     if (Dst == nullptr) {
1055       fprintf(stderr, "%d is not a supported opcode\n", Op);
1056       exit(-1);
1057     }
1058 
1059     // Copy fast-math flags on instructions that support them
1060     if (LLVMCanValueUseFastMathFlags(Src))
1061       LLVMSetFastMathFlags(Dst, LLVMGetFastMathFlags(Src));
1062 
1063     size_t NumMetadataEntries;
1064     auto *AllMetadata =
1065         LLVMInstructionGetAllMetadataOtherThanDebugLoc(Src,
1066                                                        &NumMetadataEntries);
1067     for (unsigned i = 0; i < NumMetadataEntries; ++i) {
1068       unsigned Kind = LLVMValueMetadataEntriesGetKind(AllMetadata, i);
1069       LLVMMetadataRef MD = LLVMValueMetadataEntriesGetMetadata(AllMetadata, i);
1070       LLVMSetMetadata(Dst, Kind, LLVMMetadataAsValue(Ctx, MD));
1071     }
1072     LLVMDisposeValueMetadataEntries(AllMetadata);
1073     LLVMAddMetadataToInst(Builder, Dst);
1074 
1075     check_value_kind(Dst, LLVMInstructionValueKind);
1076     return VMap[Src] = Dst;
1077   }
1078 
1079   LLVMOperandBundleRef CloneOB(LLVMOperandBundleRef Src) {
1080     size_t TagLen;
1081     const char *Tag = LLVMGetOperandBundleTag(Src, &TagLen);
1082 
1083     SmallVector<LLVMValueRef, 8> Args;
1084     for (unsigned i = 0, n = LLVMGetNumOperandBundleArgs(Src); i != n; ++i)
1085       Args.push_back(CloneValue(LLVMGetOperandBundleArgAtIndex(Src, i)));
1086 
1087     return LLVMCreateOperandBundle(Tag, TagLen, Args.data(), Args.size());
1088   }
1089 
1090   LLVMBasicBlockRef DeclareBB(LLVMBasicBlockRef Src) {
1091     // Check if this is something we already computed.
1092     {
1093       auto i = BBMap.find(Src);
1094       if (i != BBMap.end()) {
1095         return i->second;
1096       }
1097     }
1098 
1099     LLVMValueRef V = LLVMBasicBlockAsValue(Src);
1100     if (!LLVMValueIsBasicBlock(V) || LLVMValueAsBasicBlock(V) != Src)
1101       report_fatal_error("Basic block is not a basic block");
1102 
1103     const char *Name = LLVMGetBasicBlockName(Src);
1104     size_t NameLen;
1105     const char *VName = LLVMGetValueName2(V, &NameLen);
1106     if (Name != VName)
1107       report_fatal_error("Basic block name mismatch");
1108 
1109     LLVMBasicBlockRef BB = LLVMAppendBasicBlock(Fun, Name);
1110     return BBMap[Src] = BB;
1111   }
1112 
1113   LLVMBasicBlockRef CloneBB(LLVMBasicBlockRef Src) {
1114     LLVMBasicBlockRef BB = DeclareBB(Src);
1115 
1116     // Make sure ordering is correct.
1117     LLVMBasicBlockRef Prev = LLVMGetPreviousBasicBlock(Src);
1118     if (Prev)
1119       LLVMMoveBasicBlockAfter(BB, DeclareBB(Prev));
1120 
1121     LLVMValueRef First = LLVMGetFirstInstruction(Src);
1122     LLVMValueRef Last = LLVMGetLastInstruction(Src);
1123 
1124     if (First == nullptr) {
1125       if (Last != nullptr)
1126         report_fatal_error("Has no first instruction, but last one");
1127       return BB;
1128     }
1129 
1130     auto Ctx = LLVMGetModuleContext(M);
1131     LLVMBuilderRef Builder = LLVMCreateBuilderInContext(Ctx);
1132     LLVMPositionBuilderAtEnd(Builder, BB);
1133 
1134     LLVMValueRef Cur = First;
1135     LLVMValueRef Next = nullptr;
1136     while(true) {
1137       CloneInstruction(Cur, Builder);
1138       Next = LLVMGetNextInstruction(Cur);
1139       if (Next == nullptr) {
1140         if (Cur != Last)
1141           report_fatal_error("Final instruction does not match Last");
1142         break;
1143       }
1144 
1145       LLVMValueRef Prev = LLVMGetPreviousInstruction(Next);
1146       if (Prev != Cur)
1147         report_fatal_error("Next.Previous instruction is not Current");
1148 
1149       Cur = Next;
1150     }
1151 
1152     LLVMDisposeBuilder(Builder);
1153     return BB;
1154   }
1155 
1156   void CloneBBs(LLVMValueRef Src) {
1157     unsigned Count = LLVMCountBasicBlocks(Src);
1158     if (Count == 0)
1159       return;
1160 
1161     LLVMBasicBlockRef First = LLVMGetFirstBasicBlock(Src);
1162     LLVMBasicBlockRef Last = LLVMGetLastBasicBlock(Src);
1163 
1164     LLVMBasicBlockRef Cur = First;
1165     LLVMBasicBlockRef Next = nullptr;
1166     while(true) {
1167       CloneBB(Cur);
1168       Count--;
1169       Next = LLVMGetNextBasicBlock(Cur);
1170       if (Next == nullptr) {
1171         if (Cur != Last)
1172           report_fatal_error("Final basic block does not match Last");
1173         break;
1174       }
1175 
1176       LLVMBasicBlockRef Prev = LLVMGetPreviousBasicBlock(Next);
1177       if (Prev != Cur)
1178         report_fatal_error("Next.Previous basic bloc is not Current");
1179 
1180       Cur = Next;
1181     }
1182 
1183     if (Count != 0)
1184       report_fatal_error("Basic block count does not match iterration");
1185   }
1186 };
1187 
1188 static void declare_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
1189   auto Ctx = LLVMGetModuleContext(M);
1190 
1191   LLVMValueRef Begin = LLVMGetFirstGlobal(Src);
1192   LLVMValueRef End = LLVMGetLastGlobal(Src);
1193 
1194   LLVMValueRef Cur = Begin;
1195   LLVMValueRef Next = nullptr;
1196   if (!Begin) {
1197     if (End != nullptr)
1198       report_fatal_error("Range has an end but no beginning");
1199     goto FunDecl;
1200   }
1201 
1202   while (true) {
1203     size_t NameLen;
1204     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1205     if (LLVMGetNamedGlobal(M, Name))
1206       report_fatal_error("GlobalVariable already cloned");
1207     LLVMAddGlobal(M, TypeCloner(M).Clone(LLVMGlobalGetValueType(Cur)), Name);
1208 
1209     Next = LLVMGetNextGlobal(Cur);
1210     if (Next == nullptr) {
1211       if (Cur != End)
1212         report_fatal_error("");
1213       break;
1214     }
1215 
1216     LLVMValueRef Prev = LLVMGetPreviousGlobal(Next);
1217     if (Prev != Cur)
1218       report_fatal_error("Next.Previous global is not Current");
1219 
1220     Cur = Next;
1221   }
1222 
1223 FunDecl:
1224   Begin = LLVMGetFirstFunction(Src);
1225   End = LLVMGetLastFunction(Src);
1226   if (!Begin) {
1227     if (End != nullptr)
1228       report_fatal_error("Range has an end but no beginning");
1229     goto AliasDecl;
1230   }
1231 
1232   Cur = Begin;
1233   Next = nullptr;
1234   while (true) {
1235     size_t NameLen;
1236     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1237     if (LLVMGetNamedFunction(M, Name))
1238       report_fatal_error("Function already cloned");
1239     LLVMTypeRef Ty = TypeCloner(M).Clone(LLVMGlobalGetValueType(Cur));
1240 
1241     auto F = LLVMAddFunction(M, Name, Ty);
1242 
1243     // Copy attributes
1244     for (int i = LLVMAttributeFunctionIndex, c = LLVMCountParams(F);
1245          i <= c; ++i) {
1246       for (unsigned k = 0, e = LLVMGetLastEnumAttributeKind(); k < e; ++k) {
1247         if (auto SrcA = LLVMGetEnumAttributeAtIndex(Cur, i, k)) {
1248           auto Val = LLVMGetEnumAttributeValue(SrcA);
1249           auto DstA = LLVMCreateEnumAttribute(Ctx, k, Val);
1250           LLVMAddAttributeAtIndex(F, i, DstA);
1251         }
1252       }
1253     }
1254 
1255     Next = LLVMGetNextFunction(Cur);
1256     if (Next == nullptr) {
1257       if (Cur != End)
1258         report_fatal_error("Last function does not match End");
1259       break;
1260     }
1261 
1262     LLVMValueRef Prev = LLVMGetPreviousFunction(Next);
1263     if (Prev != Cur)
1264       report_fatal_error("Next.Previous function is not Current");
1265 
1266     Cur = Next;
1267   }
1268 
1269 AliasDecl:
1270   Begin = LLVMGetFirstGlobalAlias(Src);
1271   End = LLVMGetLastGlobalAlias(Src);
1272   if (!Begin) {
1273     if (End != nullptr)
1274       report_fatal_error("Range has an end but no beginning");
1275     goto GlobalIFuncDecl;
1276   }
1277 
1278   Cur = Begin;
1279   Next = nullptr;
1280   while (true) {
1281     size_t NameLen;
1282     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1283     if (LLVMGetNamedGlobalAlias(M, Name, NameLen))
1284       report_fatal_error("Global alias already cloned");
1285     LLVMTypeRef PtrType = TypeCloner(M).Clone(Cur);
1286     LLVMTypeRef ValType = TypeCloner(M).Clone(LLVMGlobalGetValueType(Cur));
1287     unsigned AddrSpace = LLVMGetPointerAddressSpace(PtrType);
1288     // FIXME: Allow NULL aliasee.
1289     LLVMAddAlias2(M, ValType, AddrSpace, LLVMGetUndef(PtrType), Name);
1290 
1291     Next = LLVMGetNextGlobalAlias(Cur);
1292     if (Next == nullptr) {
1293       if (Cur != End)
1294         report_fatal_error("");
1295       break;
1296     }
1297 
1298     LLVMValueRef Prev = LLVMGetPreviousGlobalAlias(Next);
1299     if (Prev != Cur)
1300       report_fatal_error("Next.Previous global is not Current");
1301 
1302     Cur = Next;
1303   }
1304 
1305 GlobalIFuncDecl:
1306   Begin = LLVMGetFirstGlobalIFunc(Src);
1307   End = LLVMGetLastGlobalIFunc(Src);
1308   if (!Begin) {
1309     if (End != nullptr)
1310       report_fatal_error("Range has an end but no beginning");
1311     goto NamedMDDecl;
1312   }
1313 
1314   Cur = Begin;
1315   Next = nullptr;
1316   while (true) {
1317     size_t NameLen;
1318     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1319     if (LLVMGetNamedGlobalIFunc(M, Name, NameLen))
1320       report_fatal_error("Global ifunc already cloned");
1321     LLVMTypeRef CurType = TypeCloner(M).Clone(LLVMGlobalGetValueType(Cur));
1322     // FIXME: Allow NULL resolver.
1323     LLVMAddGlobalIFunc(M, Name, NameLen,
1324                        CurType, /*addressSpace*/ 0, LLVMGetUndef(CurType));
1325 
1326     Next = LLVMGetNextGlobalIFunc(Cur);
1327     if (Next == nullptr) {
1328       if (Cur != End)
1329         report_fatal_error("");
1330       break;
1331     }
1332 
1333     LLVMValueRef Prev = LLVMGetPreviousGlobalIFunc(Next);
1334     if (Prev != Cur)
1335       report_fatal_error("Next.Previous global is not Current");
1336 
1337     Cur = Next;
1338   }
1339 
1340 NamedMDDecl:
1341   LLVMNamedMDNodeRef BeginMD = LLVMGetFirstNamedMetadata(Src);
1342   LLVMNamedMDNodeRef EndMD = LLVMGetLastNamedMetadata(Src);
1343   if (!BeginMD) {
1344     if (EndMD != nullptr)
1345       report_fatal_error("Range has an end but no beginning");
1346     return;
1347   }
1348 
1349   LLVMNamedMDNodeRef CurMD = BeginMD;
1350   LLVMNamedMDNodeRef NextMD = nullptr;
1351   while (true) {
1352     size_t NameLen;
1353     const char *Name = LLVMGetNamedMetadataName(CurMD, &NameLen);
1354     if (LLVMGetNamedMetadata(M, Name, NameLen))
1355       report_fatal_error("Named Metadata Node already cloned");
1356     LLVMGetOrInsertNamedMetadata(M, Name, NameLen);
1357 
1358     NextMD = LLVMGetNextNamedMetadata(CurMD);
1359     if (NextMD == nullptr) {
1360       if (CurMD != EndMD)
1361         report_fatal_error("");
1362       break;
1363     }
1364 
1365     LLVMNamedMDNodeRef PrevMD = LLVMGetPreviousNamedMetadata(NextMD);
1366     if (PrevMD != CurMD)
1367       report_fatal_error("Next.Previous global is not Current");
1368 
1369     CurMD = NextMD;
1370   }
1371 }
1372 
1373 static void clone_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
1374   LLVMValueRef Begin = LLVMGetFirstGlobal(Src);
1375   LLVMValueRef End = LLVMGetLastGlobal(Src);
1376 
1377   LLVMValueRef Cur = Begin;
1378   LLVMValueRef Next = nullptr;
1379   if (!Begin) {
1380     if (End != nullptr)
1381       report_fatal_error("Range has an end but no beginning");
1382     goto FunClone;
1383   }
1384 
1385   while (true) {
1386     size_t NameLen;
1387     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1388     LLVMValueRef G = LLVMGetNamedGlobal(M, Name);
1389     if (!G)
1390       report_fatal_error("GlobalVariable must have been declared already");
1391 
1392     if (auto I = LLVMGetInitializer(Cur))
1393       LLVMSetInitializer(G, clone_constant(I, M));
1394 
1395     size_t NumMetadataEntries;
1396     auto *AllMetadata = LLVMGlobalCopyAllMetadata(Cur, &NumMetadataEntries);
1397     for (unsigned i = 0; i < NumMetadataEntries; ++i) {
1398       unsigned Kind = LLVMValueMetadataEntriesGetKind(AllMetadata, i);
1399       LLVMMetadataRef MD = LLVMValueMetadataEntriesGetMetadata(AllMetadata, i);
1400       LLVMGlobalSetMetadata(G, Kind, MD);
1401     }
1402     LLVMDisposeValueMetadataEntries(AllMetadata);
1403 
1404     LLVMSetGlobalConstant(G, LLVMIsGlobalConstant(Cur));
1405     LLVMSetThreadLocal(G, LLVMIsThreadLocal(Cur));
1406     LLVMSetExternallyInitialized(G, LLVMIsExternallyInitialized(Cur));
1407     LLVMSetLinkage(G, LLVMGetLinkage(Cur));
1408     LLVMSetSection(G, LLVMGetSection(Cur));
1409     LLVMSetVisibility(G, LLVMGetVisibility(Cur));
1410     LLVMSetUnnamedAddress(G, LLVMGetUnnamedAddress(Cur));
1411     LLVMSetAlignment(G, LLVMGetAlignment(Cur));
1412 
1413     Next = LLVMGetNextGlobal(Cur);
1414     if (Next == nullptr) {
1415       if (Cur != End)
1416         report_fatal_error("");
1417       break;
1418     }
1419 
1420     LLVMValueRef Prev = LLVMGetPreviousGlobal(Next);
1421     if (Prev != Cur)
1422       report_fatal_error("Next.Previous global is not Current");
1423 
1424     Cur = Next;
1425   }
1426 
1427 FunClone:
1428   Begin = LLVMGetFirstFunction(Src);
1429   End = LLVMGetLastFunction(Src);
1430   if (!Begin) {
1431     if (End != nullptr)
1432       report_fatal_error("Range has an end but no beginning");
1433     goto AliasClone;
1434   }
1435 
1436   Cur = Begin;
1437   Next = nullptr;
1438   while (true) {
1439     size_t NameLen;
1440     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1441     LLVMValueRef Fun = LLVMGetNamedFunction(M, Name);
1442     if (!Fun)
1443       report_fatal_error("Function must have been declared already");
1444 
1445     if (LLVMHasPersonalityFn(Cur)) {
1446       size_t FNameLen;
1447       const char *FName = LLVMGetValueName2(LLVMGetPersonalityFn(Cur),
1448                                            &FNameLen);
1449       LLVMValueRef P = LLVMGetNamedFunction(M, FName);
1450       if (!P)
1451         report_fatal_error("Could not find personality function");
1452       LLVMSetPersonalityFn(Fun, P);
1453     }
1454 
1455     size_t NumMetadataEntries;
1456     auto *AllMetadata = LLVMGlobalCopyAllMetadata(Cur, &NumMetadataEntries);
1457     for (unsigned i = 0; i < NumMetadataEntries; ++i) {
1458       unsigned Kind = LLVMValueMetadataEntriesGetKind(AllMetadata, i);
1459       LLVMMetadataRef MD = LLVMValueMetadataEntriesGetMetadata(AllMetadata, i);
1460       LLVMGlobalSetMetadata(Fun, Kind, MD);
1461     }
1462     LLVMDisposeValueMetadataEntries(AllMetadata);
1463 
1464     // Copy any prefix data that may be on the function
1465     if (LLVMHasPrefixData(Cur))
1466       LLVMSetPrefixData(Fun, clone_constant(LLVMGetPrefixData(Cur), M));
1467 
1468     // Copy any prologue data that may be on the function
1469     if (LLVMHasPrologueData(Cur))
1470       LLVMSetPrologueData(Fun, clone_constant(LLVMGetPrologueData(Cur), M));
1471 
1472     FunCloner FC(Cur, Fun);
1473     FC.CloneBBs(Cur);
1474 
1475     Next = LLVMGetNextFunction(Cur);
1476     if (Next == nullptr) {
1477       if (Cur != End)
1478         report_fatal_error("Last function does not match End");
1479       break;
1480     }
1481 
1482     LLVMValueRef Prev = LLVMGetPreviousFunction(Next);
1483     if (Prev != Cur)
1484       report_fatal_error("Next.Previous function is not Current");
1485 
1486     Cur = Next;
1487   }
1488 
1489 AliasClone:
1490   Begin = LLVMGetFirstGlobalAlias(Src);
1491   End = LLVMGetLastGlobalAlias(Src);
1492   if (!Begin) {
1493     if (End != nullptr)
1494       report_fatal_error("Range has an end but no beginning");
1495     goto GlobalIFuncClone;
1496   }
1497 
1498   Cur = Begin;
1499   Next = nullptr;
1500   while (true) {
1501     size_t NameLen;
1502     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1503     LLVMValueRef Alias = LLVMGetNamedGlobalAlias(M, Name, NameLen);
1504     if (!Alias)
1505       report_fatal_error("Global alias must have been declared already");
1506 
1507     if (LLVMValueRef Aliasee = LLVMAliasGetAliasee(Cur)) {
1508       LLVMAliasSetAliasee(Alias, clone_constant(Aliasee, M));
1509     }
1510 
1511     LLVMSetLinkage(Alias, LLVMGetLinkage(Cur));
1512     LLVMSetUnnamedAddress(Alias, LLVMGetUnnamedAddress(Cur));
1513 
1514     Next = LLVMGetNextGlobalAlias(Cur);
1515     if (Next == nullptr) {
1516       if (Cur != End)
1517         report_fatal_error("Last global alias does not match End");
1518       break;
1519     }
1520 
1521     LLVMValueRef Prev = LLVMGetPreviousGlobalAlias(Next);
1522     if (Prev != Cur)
1523       report_fatal_error("Next.Previous global alias is not Current");
1524 
1525     Cur = Next;
1526   }
1527 
1528 GlobalIFuncClone:
1529   Begin = LLVMGetFirstGlobalIFunc(Src);
1530   End = LLVMGetLastGlobalIFunc(Src);
1531   if (!Begin) {
1532     if (End != nullptr)
1533       report_fatal_error("Range has an end but no beginning");
1534     goto NamedMDClone;
1535   }
1536 
1537   Cur = Begin;
1538   Next = nullptr;
1539   while (true) {
1540     size_t NameLen;
1541     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1542     LLVMValueRef IFunc = LLVMGetNamedGlobalIFunc(M, Name, NameLen);
1543     if (!IFunc)
1544       report_fatal_error("Global ifunc must have been declared already");
1545 
1546     if (LLVMValueRef Resolver = LLVMGetGlobalIFuncResolver(Cur)) {
1547       LLVMSetGlobalIFuncResolver(IFunc, clone_constant(Resolver, M));
1548     }
1549 
1550     LLVMSetLinkage(IFunc, LLVMGetLinkage(Cur));
1551     LLVMSetUnnamedAddress(IFunc, LLVMGetUnnamedAddress(Cur));
1552 
1553     Next = LLVMGetNextGlobalIFunc(Cur);
1554     if (Next == nullptr) {
1555       if (Cur != End)
1556         report_fatal_error("Last global alias does not match End");
1557       break;
1558     }
1559 
1560     LLVMValueRef Prev = LLVMGetPreviousGlobalIFunc(Next);
1561     if (Prev != Cur)
1562       report_fatal_error("Next.Previous global alias is not Current");
1563 
1564     Cur = Next;
1565   }
1566 
1567 NamedMDClone:
1568   LLVMNamedMDNodeRef BeginMD = LLVMGetFirstNamedMetadata(Src);
1569   LLVMNamedMDNodeRef EndMD = LLVMGetLastNamedMetadata(Src);
1570   if (!BeginMD) {
1571     if (EndMD != nullptr)
1572       report_fatal_error("Range has an end but no beginning");
1573     return;
1574   }
1575 
1576   LLVMNamedMDNodeRef CurMD = BeginMD;
1577   LLVMNamedMDNodeRef NextMD = nullptr;
1578   while (true) {
1579     size_t NameLen;
1580     const char *Name = LLVMGetNamedMetadataName(CurMD, &NameLen);
1581     LLVMNamedMDNodeRef NamedMD = LLVMGetNamedMetadata(M, Name, NameLen);
1582     if (!NamedMD)
1583       report_fatal_error("Named MD Node must have been declared already");
1584 
1585     unsigned OperandCount = LLVMGetNamedMetadataNumOperands(Src, Name);
1586     LLVMValueRef *OperandBuf = static_cast<LLVMValueRef *>(
1587               safe_malloc(OperandCount * sizeof(LLVMValueRef)));
1588     LLVMGetNamedMetadataOperands(Src, Name, OperandBuf);
1589     for (unsigned i = 0, e = OperandCount; i != e; ++i) {
1590       LLVMAddNamedMetadataOperand(M, Name, OperandBuf[i]);
1591     }
1592     free(OperandBuf);
1593 
1594     NextMD = LLVMGetNextNamedMetadata(CurMD);
1595     if (NextMD == nullptr) {
1596       if (CurMD != EndMD)
1597         report_fatal_error("Last Named MD Node does not match End");
1598       break;
1599     }
1600 
1601     LLVMNamedMDNodeRef PrevMD = LLVMGetPreviousNamedMetadata(NextMD);
1602     if (PrevMD != CurMD)
1603       report_fatal_error("Next.Previous Named MD Node is not Current");
1604 
1605     CurMD = NextMD;
1606   }
1607 }
1608 
1609 int llvm_echo(void) {
1610   LLVMEnablePrettyStackTrace();
1611 
1612   LLVMContextRef Ctx = LLVMContextCreate();
1613   LLVMModuleRef Src = llvm_load_module(Ctx, false, true);
1614   size_t SourceFileLen;
1615   const char *SourceFileName = LLVMGetSourceFileName(Src, &SourceFileLen);
1616   size_t ModuleIdentLen;
1617   const char *ModuleName = LLVMGetModuleIdentifier(Src, &ModuleIdentLen);
1618   LLVMModuleRef M = LLVMModuleCreateWithNameInContext(ModuleName, Ctx);
1619 
1620   LLVMSetSourceFileName(M, SourceFileName, SourceFileLen);
1621   LLVMSetModuleIdentifier(M, ModuleName, ModuleIdentLen);
1622 
1623   LLVMSetTarget(M, LLVMGetTarget(Src));
1624   LLVMSetModuleDataLayout(M, LLVMGetModuleDataLayout(Src));
1625   if (strcmp(LLVMGetDataLayoutStr(M), LLVMGetDataLayoutStr(Src)))
1626     report_fatal_error("Inconsistent DataLayout string representation");
1627 
1628   size_t ModuleInlineAsmLen;
1629   const char *ModuleAsm = LLVMGetModuleInlineAsm(Src, &ModuleInlineAsmLen);
1630   LLVMSetModuleInlineAsm2(M, ModuleAsm, ModuleInlineAsmLen);
1631 
1632   declare_symbols(Src, M);
1633   clone_symbols(Src, M);
1634   char *Str = LLVMPrintModuleToString(M);
1635   fputs(Str, stdout);
1636 
1637   LLVMDisposeMessage(Str);
1638   LLVMDisposeModule(Src);
1639   LLVMDisposeModule(M);
1640   LLVMContextDispose(Ctx);
1641 
1642   return 0;
1643 }
1644