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