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