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