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