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