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