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 opaque 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 LLVMVectorTypeKind:
143         return LLVMVectorType(
144           Clone(LLVMGetElementType(Src)),
145           LLVMGetVectorSize(Src)
146         );
147       case LLVMScalableVectorTypeKind:
148         return LLVMScalableVectorType(Clone(LLVMGetElementType(Src)),
149                                       LLVMGetVectorSize(Src));
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 constant 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   // Try ConstantVector
361   if (LLVMIsAConstantVector(Cst)) {
362     check_value_kind(Cst, LLVMConstantVectorValueKind);
363     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
364     unsigned EltCount = LLVMGetVectorSize(Ty);
365     SmallVector<LLVMValueRef, 8> Elts;
366     for (unsigned i = 0; i < EltCount; i++)
367       Elts.push_back(clone_constant(LLVMGetOperand(Cst, i), M));
368     return LLVMConstVector(Elts.data(), EltCount);
369   }
370 
371   // Try ConstantDataVector
372   if (LLVMIsAConstantDataVector(Cst)) {
373     check_value_kind(Cst, LLVMConstantDataVectorValueKind);
374     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
375     unsigned EltCount = LLVMGetVectorSize(Ty);
376     SmallVector<LLVMValueRef, 8> Elts;
377     for (unsigned i = 0; i < EltCount; i++)
378       Elts.push_back(clone_constant(LLVMGetElementAsConstant(Cst, i), M));
379     return LLVMConstVector(Elts.data(), EltCount);
380   }
381 
382   // At this point, if it's not a constant expression, it's a kind of constant
383   // which is not supported
384   if (!LLVMIsAConstantExpr(Cst))
385     report_fatal_error("Unsupported constant kind");
386 
387   // At this point, it must be a constant expression
388   check_value_kind(Cst, LLVMConstantExprValueKind);
389 
390   LLVMOpcode Op = LLVMGetConstOpcode(Cst);
391   switch(Op) {
392     case LLVMBitCast:
393       return LLVMConstBitCast(clone_constant(LLVMGetOperand(Cst, 0), M),
394                               TypeCloner(M).Clone(Cst));
395     default:
396       fprintf(stderr, "%d is not a supported opcode for constant expressions\n",
397               Op);
398       exit(-1);
399   }
400 }
401 
402 struct FunCloner {
403   LLVMValueRef Fun;
404   LLVMModuleRef M;
405 
406   ValueMap VMap;
407   BasicBlockMap BBMap;
408 
409   FunCloner(LLVMValueRef Src, LLVMValueRef Dst): Fun(Dst),
410     M(LLVMGetGlobalParent(Fun)), VMap(clone_params(Src, Dst)) {}
411 
412   LLVMTypeRef CloneType(LLVMTypeRef Src) {
413     return TypeCloner(M).Clone(Src);
414   }
415 
416   LLVMTypeRef CloneType(LLVMValueRef Src) {
417     return TypeCloner(M).Clone(Src);
418   }
419 
420   // Try to clone everything in the llvm::Value hierarchy.
421   LLVMValueRef CloneValue(LLVMValueRef Src) {
422     // First, the value may be constant.
423     if (LLVMIsAConstant(Src))
424       return clone_constant(Src, M);
425 
426     // Function argument should always be in the map already.
427     auto i = VMap.find(Src);
428     if (i != VMap.end())
429       return i->second;
430 
431     if (!LLVMIsAInstruction(Src))
432       report_fatal_error("Expected an instruction");
433 
434     auto Ctx = LLVMGetModuleContext(M);
435     auto Builder = LLVMCreateBuilderInContext(Ctx);
436     auto BB = DeclareBB(LLVMGetInstructionParent(Src));
437     LLVMPositionBuilderAtEnd(Builder, BB);
438     auto Dst = CloneInstruction(Src, Builder);
439     LLVMDisposeBuilder(Builder);
440     return Dst;
441   }
442 
443   void CloneAttrs(LLVMValueRef Src, LLVMValueRef Dst) {
444     auto Ctx = LLVMGetModuleContext(M);
445     int ArgCount = LLVMGetNumArgOperands(Src);
446     for (int i = LLVMAttributeReturnIndex; i <= ArgCount; i++) {
447       for (unsigned k = 0, e = LLVMGetLastEnumAttributeKind(); k < e; ++k) {
448         if (auto SrcA = LLVMGetCallSiteEnumAttribute(Src, i, k)) {
449           auto Val = LLVMGetEnumAttributeValue(SrcA);
450           auto A = LLVMCreateEnumAttribute(Ctx, k, Val);
451           LLVMAddCallSiteAttribute(Dst, i, A);
452         }
453       }
454     }
455   }
456 
457   LLVMValueRef CloneInstruction(LLVMValueRef Src, LLVMBuilderRef Builder) {
458     check_value_kind(Src, LLVMInstructionValueKind);
459     if (!LLVMIsAInstruction(Src))
460       report_fatal_error("Expected an instruction");
461 
462     size_t NameLen;
463     const char *Name = LLVMGetValueName2(Src, &NameLen);
464 
465     // Check if this is something we already computed.
466     {
467       auto i = VMap.find(Src);
468       if (i != VMap.end()) {
469         // If we have a hit, it means we already generated the instruction
470         // as a dependency to something else. We need to make sure
471         // it is ordered properly.
472         auto I = i->second;
473         LLVMInstructionRemoveFromParent(I);
474         LLVMInsertIntoBuilderWithName(Builder, I, Name);
475         return I;
476       }
477     }
478 
479     // We tried everything, it must be an instruction
480     // that hasn't been generated already.
481     LLVMValueRef Dst = nullptr;
482 
483     LLVMOpcode Op = LLVMGetInstructionOpcode(Src);
484     switch(Op) {
485       case LLVMRet: {
486         int OpCount = LLVMGetNumOperands(Src);
487         if (OpCount == 0)
488           Dst = LLVMBuildRetVoid(Builder);
489         else
490           Dst = LLVMBuildRet(Builder, CloneValue(LLVMGetOperand(Src, 0)));
491         break;
492       }
493       case LLVMBr: {
494         if (!LLVMIsConditional(Src)) {
495           LLVMValueRef SrcOp = LLVMGetOperand(Src, 0);
496           LLVMBasicBlockRef SrcBB = LLVMValueAsBasicBlock(SrcOp);
497           Dst = LLVMBuildBr(Builder, DeclareBB(SrcBB));
498           break;
499         }
500 
501         LLVMValueRef Cond = LLVMGetCondition(Src);
502         LLVMValueRef Else = LLVMGetOperand(Src, 1);
503         LLVMBasicBlockRef ElseBB = DeclareBB(LLVMValueAsBasicBlock(Else));
504         LLVMValueRef Then = LLVMGetOperand(Src, 2);
505         LLVMBasicBlockRef ThenBB = DeclareBB(LLVMValueAsBasicBlock(Then));
506         Dst = LLVMBuildCondBr(Builder, CloneValue(Cond), ThenBB, ElseBB);
507         break;
508       }
509       case LLVMSwitch:
510       case LLVMIndirectBr:
511         break;
512       case LLVMInvoke: {
513         SmallVector<LLVMValueRef, 8> Args;
514         int ArgCount = LLVMGetNumArgOperands(Src);
515         for (int i = 0; i < ArgCount; i++)
516           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
517         LLVMValueRef Fn = CloneValue(LLVMGetCalledValue(Src));
518         LLVMBasicBlockRef Then = DeclareBB(LLVMGetNormalDest(Src));
519         LLVMBasicBlockRef Unwind = DeclareBB(LLVMGetUnwindDest(Src));
520         Dst = LLVMBuildInvoke(Builder, Fn, Args.data(), ArgCount,
521                               Then, Unwind, Name);
522         CloneAttrs(Src, Dst);
523         break;
524       }
525       case LLVMUnreachable:
526         Dst = LLVMBuildUnreachable(Builder);
527         break;
528       case LLVMAdd: {
529         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
530         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
531         Dst = LLVMBuildAdd(Builder, LHS, RHS, Name);
532         break;
533       }
534       case LLVMSub: {
535         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
536         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
537         Dst = LLVMBuildSub(Builder, LHS, RHS, Name);
538         break;
539       }
540       case LLVMMul: {
541         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
542         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
543         Dst = LLVMBuildMul(Builder, LHS, RHS, Name);
544         break;
545       }
546       case LLVMUDiv: {
547         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
548         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
549         Dst = LLVMBuildUDiv(Builder, LHS, RHS, Name);
550         break;
551       }
552       case LLVMSDiv: {
553         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
554         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
555         Dst = LLVMBuildSDiv(Builder, LHS, RHS, Name);
556         break;
557       }
558       case LLVMURem: {
559         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
560         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
561         Dst = LLVMBuildURem(Builder, LHS, RHS, Name);
562         break;
563       }
564       case LLVMSRem: {
565         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
566         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
567         Dst = LLVMBuildSRem(Builder, LHS, RHS, Name);
568         break;
569       }
570       case LLVMShl: {
571         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
572         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
573         Dst = LLVMBuildShl(Builder, LHS, RHS, Name);
574         break;
575       }
576       case LLVMLShr: {
577         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
578         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
579         Dst = LLVMBuildLShr(Builder, LHS, RHS, Name);
580         break;
581       }
582       case LLVMAShr: {
583         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
584         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
585         Dst = LLVMBuildAShr(Builder, LHS, RHS, Name);
586         break;
587       }
588       case LLVMAnd: {
589         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
590         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
591         Dst = LLVMBuildAnd(Builder, LHS, RHS, Name);
592         break;
593       }
594       case LLVMOr: {
595         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
596         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
597         Dst = LLVMBuildOr(Builder, LHS, RHS, Name);
598         break;
599       }
600       case LLVMXor: {
601         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
602         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
603         Dst = LLVMBuildXor(Builder, LHS, RHS, Name);
604         break;
605       }
606       case LLVMAlloca: {
607         LLVMTypeRef Ty = CloneType(LLVMGetAllocatedType(Src));
608         Dst = LLVMBuildAlloca(Builder, Ty, Name);
609         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
610         break;
611       }
612       case LLVMLoad: {
613         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
614         Dst = LLVMBuildLoad(Builder, Ptr, Name);
615         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
616         LLVMSetOrdering(Dst, LLVMGetOrdering(Src));
617         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
618         break;
619       }
620       case LLVMStore: {
621         LLVMValueRef Val = CloneValue(LLVMGetOperand(Src, 0));
622         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 1));
623         Dst = LLVMBuildStore(Builder, Val, Ptr);
624         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
625         LLVMSetOrdering(Dst, LLVMGetOrdering(Src));
626         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
627         break;
628       }
629       case LLVMGetElementPtr: {
630         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
631         SmallVector<LLVMValueRef, 8> Idx;
632         int NumIdx = LLVMGetNumIndices(Src);
633         for (int i = 1; i <= NumIdx; i++)
634           Idx.push_back(CloneValue(LLVMGetOperand(Src, i)));
635         if (LLVMIsInBounds(Src))
636           Dst = LLVMBuildInBoundsGEP(Builder, Ptr, Idx.data(), NumIdx, Name);
637         else
638           Dst = LLVMBuildGEP(Builder, Ptr, Idx.data(), NumIdx, Name);
639         break;
640       }
641       case LLVMAtomicRMW: {
642         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
643         LLVMValueRef Val = CloneValue(LLVMGetOperand(Src, 1));
644         LLVMAtomicRMWBinOp BinOp = LLVMGetAtomicRMWBinOp(Src);
645         LLVMAtomicOrdering Ord = LLVMGetOrdering(Src);
646         LLVMBool SingleThread = LLVMIsAtomicSingleThread(Src);
647         Dst = LLVMBuildAtomicRMW(Builder, BinOp, Ptr, Val, Ord, SingleThread);
648         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
649         LLVMSetValueName2(Dst, Name, NameLen);
650         break;
651       }
652       case LLVMAtomicCmpXchg: {
653         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
654         LLVMValueRef Cmp = CloneValue(LLVMGetOperand(Src, 1));
655         LLVMValueRef New = CloneValue(LLVMGetOperand(Src, 2));
656         LLVMAtomicOrdering Succ = LLVMGetCmpXchgSuccessOrdering(Src);
657         LLVMAtomicOrdering Fail = LLVMGetCmpXchgFailureOrdering(Src);
658         LLVMBool SingleThread = LLVMIsAtomicSingleThread(Src);
659 
660         Dst = LLVMBuildAtomicCmpXchg(Builder, Ptr, Cmp, New, Succ, Fail,
661                                      SingleThread);
662         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
663         LLVMSetWeak(Dst, LLVMGetWeak(Src));
664         LLVMSetValueName2(Dst, Name, NameLen);
665         break;
666       }
667       case LLVMBitCast: {
668         LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 0));
669         Dst = LLVMBuildBitCast(Builder, V, CloneType(Src), Name);
670         break;
671       }
672       case LLVMICmp: {
673         LLVMIntPredicate Pred = LLVMGetICmpPredicate(Src);
674         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
675         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
676         Dst = LLVMBuildICmp(Builder, Pred, LHS, RHS, Name);
677         break;
678       }
679       case LLVMPHI: {
680         // We need to aggressively set things here because of loops.
681         VMap[Src] = Dst = LLVMBuildPhi(Builder, CloneType(Src), Name);
682 
683         SmallVector<LLVMValueRef, 8> Values;
684         SmallVector<LLVMBasicBlockRef, 8> Blocks;
685 
686         unsigned IncomingCount = LLVMCountIncoming(Src);
687         for (unsigned i = 0; i < IncomingCount; ++i) {
688           Blocks.push_back(DeclareBB(LLVMGetIncomingBlock(Src, i)));
689           Values.push_back(CloneValue(LLVMGetIncomingValue(Src, i)));
690         }
691 
692         LLVMAddIncoming(Dst, Values.data(), Blocks.data(), IncomingCount);
693         return Dst;
694       }
695       case LLVMCall: {
696         SmallVector<LLVMValueRef, 8> Args;
697         int ArgCount = LLVMGetNumArgOperands(Src);
698         for (int i = 0; i < ArgCount; i++)
699           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
700         LLVMValueRef Fn = CloneValue(LLVMGetCalledValue(Src));
701         Dst = LLVMBuildCall(Builder, Fn, Args.data(), ArgCount, Name);
702         LLVMSetTailCall(Dst, LLVMIsTailCall(Src));
703         CloneAttrs(Src, Dst);
704         break;
705       }
706       case LLVMResume: {
707         Dst = LLVMBuildResume(Builder, CloneValue(LLVMGetOperand(Src, 0)));
708         break;
709       }
710       case LLVMLandingPad: {
711         // The landing pad API is a bit screwed up for historical reasons.
712         Dst = LLVMBuildLandingPad(Builder, CloneType(Src), nullptr, 0, Name);
713         unsigned NumClauses = LLVMGetNumClauses(Src);
714         for (unsigned i = 0; i < NumClauses; ++i)
715           LLVMAddClause(Dst, CloneValue(LLVMGetClause(Src, i)));
716         LLVMSetCleanup(Dst, LLVMIsCleanup(Src));
717         break;
718       }
719       case LLVMCleanupRet: {
720         LLVMValueRef CatchPad = CloneValue(LLVMGetOperand(Src, 0));
721         LLVMBasicBlockRef Unwind = nullptr;
722         if (LLVMBasicBlockRef UDest = LLVMGetUnwindDest(Src))
723           Unwind = DeclareBB(UDest);
724         Dst = LLVMBuildCleanupRet(Builder, CatchPad, Unwind);
725         break;
726       }
727       case LLVMCatchRet: {
728         LLVMValueRef CatchPad = CloneValue(LLVMGetOperand(Src, 0));
729         LLVMBasicBlockRef SuccBB = DeclareBB(LLVMGetSuccessor(Src, 0));
730         Dst = LLVMBuildCatchRet(Builder, CatchPad, SuccBB);
731         break;
732       }
733       case LLVMCatchPad: {
734         LLVMValueRef ParentPad = CloneValue(LLVMGetParentCatchSwitch(Src));
735         SmallVector<LLVMValueRef, 8> Args;
736         int ArgCount = LLVMGetNumArgOperands(Src);
737         for (int i = 0; i < ArgCount; i++)
738           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
739         Dst = LLVMBuildCatchPad(Builder, ParentPad,
740                                 Args.data(), ArgCount, Name);
741         break;
742       }
743       case LLVMCleanupPad: {
744         LLVMValueRef ParentPad = CloneValue(LLVMGetOperand(Src, 0));
745         SmallVector<LLVMValueRef, 8> Args;
746         int ArgCount = LLVMGetNumArgOperands(Src);
747         for (int i = 0; i < ArgCount; i++)
748           Args.push_back(CloneValue(LLVMGetArgOperand(Src, i)));
749         Dst = LLVMBuildCleanupPad(Builder, ParentPad,
750                                   Args.data(), ArgCount, Name);
751         break;
752       }
753       case LLVMCatchSwitch: {
754         LLVMValueRef ParentPad = CloneValue(LLVMGetOperand(Src, 0));
755         LLVMBasicBlockRef UnwindBB = nullptr;
756         if (LLVMBasicBlockRef UDest = LLVMGetUnwindDest(Src)) {
757           UnwindBB = DeclareBB(UDest);
758         }
759         unsigned NumHandlers = LLVMGetNumHandlers(Src);
760         Dst = LLVMBuildCatchSwitch(Builder, ParentPad, UnwindBB, NumHandlers, Name);
761         if (NumHandlers > 0) {
762           LLVMBasicBlockRef *Handlers = static_cast<LLVMBasicBlockRef*>(
763                        safe_malloc(NumHandlers * sizeof(LLVMBasicBlockRef)));
764           LLVMGetHandlers(Src, Handlers);
765           for (unsigned i = 0; i < NumHandlers; i++)
766             LLVMAddHandler(Dst, DeclareBB(Handlers[i]));
767           free(Handlers);
768         }
769         break;
770       }
771       case LLVMExtractValue: {
772         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
773         if (LLVMGetNumIndices(Src) > 1)
774           report_fatal_error("ExtractValue: Expected only one index");
775         else if (LLVMGetNumIndices(Src) < 1)
776           report_fatal_error("ExtractValue: Expected an index");
777         auto I = LLVMGetIndices(Src)[0];
778         Dst = LLVMBuildExtractValue(Builder, Agg, I, Name);
779         break;
780       }
781       case LLVMInsertValue: {
782         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
783         LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 1));
784         if (LLVMGetNumIndices(Src) > 1)
785           report_fatal_error("InsertValue: Expected only one index");
786         else if (LLVMGetNumIndices(Src) < 1)
787           report_fatal_error("InsertValue: Expected an index");
788         auto I = LLVMGetIndices(Src)[0];
789         Dst = LLVMBuildInsertValue(Builder, Agg, V, I, Name);
790         break;
791       }
792       case LLVMExtractElement: {
793         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
794         LLVMValueRef Index = CloneValue(LLVMGetOperand(Src, 1));
795         Dst = LLVMBuildExtractElement(Builder, Agg, Index, Name);
796         break;
797       }
798       case LLVMInsertElement: {
799         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
800         LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 1));
801         LLVMValueRef Index = CloneValue(LLVMGetOperand(Src, 2));
802         Dst = LLVMBuildInsertElement(Builder, Agg, V, Index, Name);
803         break;
804       }
805       case LLVMShuffleVector: {
806         LLVMValueRef Agg0 = CloneValue(LLVMGetOperand(Src, 0));
807         LLVMValueRef Agg1 = CloneValue(LLVMGetOperand(Src, 1));
808         SmallVector<LLVMValueRef, 8> MaskElts;
809         unsigned NumMaskElts = LLVMGetNumMaskElements(Src);
810         for (unsigned i = 0; i < NumMaskElts; i++) {
811           int Val = LLVMGetMaskValue(Src, i);
812           if (Val == LLVMGetUndefMaskElem()) {
813             MaskElts.push_back(LLVMGetUndef(LLVMInt64Type()));
814           } else {
815             MaskElts.push_back(LLVMConstInt(LLVMInt64Type(), Val, true));
816           }
817         }
818         LLVMValueRef Mask = LLVMConstVector(MaskElts.data(), NumMaskElts);
819         Dst = LLVMBuildShuffleVector(Builder, Agg0, Agg1, Mask, Name);
820         break;
821       }
822       case LLVMFreeze: {
823         LLVMValueRef Arg = CloneValue(LLVMGetOperand(Src, 0));
824         Dst = LLVMBuildFreeze(Builder, Arg, Name);
825         break;
826       }
827       default:
828         break;
829     }
830 
831     if (Dst == nullptr) {
832       fprintf(stderr, "%d is not a supported opcode\n", Op);
833       exit(-1);
834     }
835 
836     auto Ctx = LLVMGetModuleContext(M);
837     size_t NumMetadataEntries;
838     auto *AllMetadata =
839         LLVMInstructionGetAllMetadataOtherThanDebugLoc(Src,
840                                                        &NumMetadataEntries);
841     for (unsigned i = 0; i < NumMetadataEntries; ++i) {
842       unsigned Kind = LLVMValueMetadataEntriesGetKind(AllMetadata, i);
843       LLVMMetadataRef MD = LLVMValueMetadataEntriesGetMetadata(AllMetadata, i);
844       LLVMSetMetadata(Dst, Kind, LLVMMetadataAsValue(Ctx, MD));
845     }
846     LLVMDisposeValueMetadataEntries(AllMetadata);
847     LLVMSetInstDebugLocation(Builder, Dst);
848 
849     check_value_kind(Dst, LLVMInstructionValueKind);
850     return VMap[Src] = Dst;
851   }
852 
853   LLVMBasicBlockRef DeclareBB(LLVMBasicBlockRef Src) {
854     // Check if this is something we already computed.
855     {
856       auto i = BBMap.find(Src);
857       if (i != BBMap.end()) {
858         return i->second;
859       }
860     }
861 
862     LLVMValueRef V = LLVMBasicBlockAsValue(Src);
863     if (!LLVMValueIsBasicBlock(V) || LLVMValueAsBasicBlock(V) != Src)
864       report_fatal_error("Basic block is not a basic block");
865 
866     const char *Name = LLVMGetBasicBlockName(Src);
867     size_t NameLen;
868     const char *VName = LLVMGetValueName2(V, &NameLen);
869     if (Name != VName)
870       report_fatal_error("Basic block name mismatch");
871 
872     LLVMBasicBlockRef BB = LLVMAppendBasicBlock(Fun, Name);
873     return BBMap[Src] = BB;
874   }
875 
876   LLVMBasicBlockRef CloneBB(LLVMBasicBlockRef Src) {
877     LLVMBasicBlockRef BB = DeclareBB(Src);
878 
879     // Make sure ordering is correct.
880     LLVMBasicBlockRef Prev = LLVMGetPreviousBasicBlock(Src);
881     if (Prev)
882       LLVMMoveBasicBlockAfter(BB, DeclareBB(Prev));
883 
884     LLVMValueRef First = LLVMGetFirstInstruction(Src);
885     LLVMValueRef Last = LLVMGetLastInstruction(Src);
886 
887     if (First == nullptr) {
888       if (Last != nullptr)
889         report_fatal_error("Has no first instruction, but last one");
890       return BB;
891     }
892 
893     auto Ctx = LLVMGetModuleContext(M);
894     LLVMBuilderRef Builder = LLVMCreateBuilderInContext(Ctx);
895     LLVMPositionBuilderAtEnd(Builder, BB);
896 
897     LLVMValueRef Cur = First;
898     LLVMValueRef Next = nullptr;
899     while(true) {
900       CloneInstruction(Cur, Builder);
901       Next = LLVMGetNextInstruction(Cur);
902       if (Next == nullptr) {
903         if (Cur != Last)
904           report_fatal_error("Final instruction does not match Last");
905         break;
906       }
907 
908       LLVMValueRef Prev = LLVMGetPreviousInstruction(Next);
909       if (Prev != Cur)
910         report_fatal_error("Next.Previous instruction is not Current");
911 
912       Cur = Next;
913     }
914 
915     LLVMDisposeBuilder(Builder);
916     return BB;
917   }
918 
919   void CloneBBs(LLVMValueRef Src) {
920     unsigned Count = LLVMCountBasicBlocks(Src);
921     if (Count == 0)
922       return;
923 
924     LLVMBasicBlockRef First = LLVMGetFirstBasicBlock(Src);
925     LLVMBasicBlockRef Last = LLVMGetLastBasicBlock(Src);
926 
927     LLVMBasicBlockRef Cur = First;
928     LLVMBasicBlockRef Next = nullptr;
929     while(true) {
930       CloneBB(Cur);
931       Count--;
932       Next = LLVMGetNextBasicBlock(Cur);
933       if (Next == nullptr) {
934         if (Cur != Last)
935           report_fatal_error("Final basic block does not match Last");
936         break;
937       }
938 
939       LLVMBasicBlockRef Prev = LLVMGetPreviousBasicBlock(Next);
940       if (Prev != Cur)
941         report_fatal_error("Next.Previous basic bloc is not Current");
942 
943       Cur = Next;
944     }
945 
946     if (Count != 0)
947       report_fatal_error("Basic block count does not match iterration");
948   }
949 };
950 
951 static void declare_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
952   auto Ctx = LLVMGetModuleContext(M);
953 
954   LLVMValueRef Begin = LLVMGetFirstGlobal(Src);
955   LLVMValueRef End = LLVMGetLastGlobal(Src);
956 
957   LLVMValueRef Cur = Begin;
958   LLVMValueRef Next = nullptr;
959   if (!Begin) {
960     if (End != nullptr)
961       report_fatal_error("Range has an end but no beginning");
962     goto FunDecl;
963   }
964 
965   while (true) {
966     size_t NameLen;
967     const char *Name = LLVMGetValueName2(Cur, &NameLen);
968     if (LLVMGetNamedGlobal(M, Name))
969       report_fatal_error("GlobalVariable already cloned");
970     LLVMAddGlobal(M, LLVMGetElementType(TypeCloner(M).Clone(Cur)), Name);
971 
972     Next = LLVMGetNextGlobal(Cur);
973     if (Next == nullptr) {
974       if (Cur != End)
975         report_fatal_error("");
976       break;
977     }
978 
979     LLVMValueRef Prev = LLVMGetPreviousGlobal(Next);
980     if (Prev != Cur)
981       report_fatal_error("Next.Previous global is not Current");
982 
983     Cur = Next;
984   }
985 
986 FunDecl:
987   Begin = LLVMGetFirstFunction(Src);
988   End = LLVMGetLastFunction(Src);
989   if (!Begin) {
990     if (End != nullptr)
991       report_fatal_error("Range has an end but no beginning");
992     goto AliasDecl;
993   }
994 
995   Cur = Begin;
996   Next = nullptr;
997   while (true) {
998     size_t NameLen;
999     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1000     if (LLVMGetNamedFunction(M, Name))
1001       report_fatal_error("Function already cloned");
1002     auto Ty = LLVMGetElementType(TypeCloner(M).Clone(Cur));
1003     auto F = LLVMAddFunction(M, Name, Ty);
1004 
1005     // Copy attributes
1006     for (int i = LLVMAttributeFunctionIndex, c = LLVMCountParams(F);
1007          i <= c; ++i) {
1008       for (unsigned k = 0, e = LLVMGetLastEnumAttributeKind(); k < e; ++k) {
1009         if (auto SrcA = LLVMGetEnumAttributeAtIndex(Cur, i, k)) {
1010           auto Val = LLVMGetEnumAttributeValue(SrcA);
1011           auto DstA = LLVMCreateEnumAttribute(Ctx, k, Val);
1012           LLVMAddAttributeAtIndex(F, i, DstA);
1013         }
1014       }
1015     }
1016 
1017     Next = LLVMGetNextFunction(Cur);
1018     if (Next == nullptr) {
1019       if (Cur != End)
1020         report_fatal_error("Last function does not match End");
1021       break;
1022     }
1023 
1024     LLVMValueRef Prev = LLVMGetPreviousFunction(Next);
1025     if (Prev != Cur)
1026       report_fatal_error("Next.Previous function is not Current");
1027 
1028     Cur = Next;
1029   }
1030 
1031 AliasDecl:
1032   Begin = LLVMGetFirstGlobalAlias(Src);
1033   End = LLVMGetLastGlobalAlias(Src);
1034   if (!Begin) {
1035     if (End != nullptr)
1036       report_fatal_error("Range has an end but no beginning");
1037     goto GlobalIFuncDecl;
1038   }
1039 
1040   Cur = Begin;
1041   Next = nullptr;
1042   while (true) {
1043     size_t NameLen;
1044     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1045     if (LLVMGetNamedGlobalAlias(M, Name, NameLen))
1046       report_fatal_error("Global alias already cloned");
1047     LLVMTypeRef CurType = TypeCloner(M).Clone(Cur);
1048     // FIXME: Allow NULL aliasee.
1049     LLVMAddAlias(M, CurType, LLVMGetUndef(CurType), Name);
1050 
1051     Next = LLVMGetNextGlobalAlias(Cur);
1052     if (Next == nullptr) {
1053       if (Cur != End)
1054         report_fatal_error("");
1055       break;
1056     }
1057 
1058     LLVMValueRef Prev = LLVMGetPreviousGlobalAlias(Next);
1059     if (Prev != Cur)
1060       report_fatal_error("Next.Previous global is not Current");
1061 
1062     Cur = Next;
1063   }
1064 
1065 GlobalIFuncDecl:
1066   Begin = LLVMGetFirstGlobalIFunc(Src);
1067   End = LLVMGetLastGlobalIFunc(Src);
1068   if (!Begin) {
1069     if (End != nullptr)
1070       report_fatal_error("Range has an end but no beginning");
1071     goto NamedMDDecl;
1072   }
1073 
1074   Cur = Begin;
1075   Next = nullptr;
1076   while (true) {
1077     size_t NameLen;
1078     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1079     if (LLVMGetNamedGlobalIFunc(M, Name, NameLen))
1080       report_fatal_error("Global ifunc already cloned");
1081     LLVMTypeRef CurType = TypeCloner(M).Clone(LLVMGlobalGetValueType(Cur));
1082     // FIXME: Allow NULL resolver.
1083     LLVMAddGlobalIFunc(M, Name, NameLen,
1084                        CurType, /*addressSpace*/ 0, LLVMGetUndef(CurType));
1085 
1086     Next = LLVMGetNextGlobalIFunc(Cur);
1087     if (Next == nullptr) {
1088       if (Cur != End)
1089         report_fatal_error("");
1090       break;
1091     }
1092 
1093     LLVMValueRef Prev = LLVMGetPreviousGlobalIFunc(Next);
1094     if (Prev != Cur)
1095       report_fatal_error("Next.Previous global is not Current");
1096 
1097     Cur = Next;
1098   }
1099 
1100 NamedMDDecl:
1101   LLVMNamedMDNodeRef BeginMD = LLVMGetFirstNamedMetadata(Src);
1102   LLVMNamedMDNodeRef EndMD = LLVMGetLastNamedMetadata(Src);
1103   if (!BeginMD) {
1104     if (EndMD != nullptr)
1105       report_fatal_error("Range has an end but no beginning");
1106     return;
1107   }
1108 
1109   LLVMNamedMDNodeRef CurMD = BeginMD;
1110   LLVMNamedMDNodeRef NextMD = nullptr;
1111   while (true) {
1112     size_t NameLen;
1113     const char *Name = LLVMGetNamedMetadataName(CurMD, &NameLen);
1114     if (LLVMGetNamedMetadata(M, Name, NameLen))
1115       report_fatal_error("Named Metadata Node already cloned");
1116     LLVMGetOrInsertNamedMetadata(M, Name, NameLen);
1117 
1118     NextMD = LLVMGetNextNamedMetadata(CurMD);
1119     if (NextMD == nullptr) {
1120       if (CurMD != EndMD)
1121         report_fatal_error("");
1122       break;
1123     }
1124 
1125     LLVMNamedMDNodeRef PrevMD = LLVMGetPreviousNamedMetadata(NextMD);
1126     if (PrevMD != CurMD)
1127       report_fatal_error("Next.Previous global is not Current");
1128 
1129     CurMD = NextMD;
1130   }
1131 }
1132 
1133 static void clone_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
1134   LLVMValueRef Begin = LLVMGetFirstGlobal(Src);
1135   LLVMValueRef End = LLVMGetLastGlobal(Src);
1136 
1137   LLVMValueRef Cur = Begin;
1138   LLVMValueRef Next = nullptr;
1139   if (!Begin) {
1140     if (End != nullptr)
1141       report_fatal_error("Range has an end but no beginning");
1142     goto FunClone;
1143   }
1144 
1145   while (true) {
1146     size_t NameLen;
1147     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1148     LLVMValueRef G = LLVMGetNamedGlobal(M, Name);
1149     if (!G)
1150       report_fatal_error("GlobalVariable must have been declared already");
1151 
1152     if (auto I = LLVMGetInitializer(Cur))
1153       LLVMSetInitializer(G, clone_constant(I, M));
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(G, Kind, MD);
1161     }
1162     LLVMDisposeValueMetadataEntries(AllMetadata);
1163 
1164     LLVMSetGlobalConstant(G, LLVMIsGlobalConstant(Cur));
1165     LLVMSetThreadLocal(G, LLVMIsThreadLocal(Cur));
1166     LLVMSetExternallyInitialized(G, LLVMIsExternallyInitialized(Cur));
1167     LLVMSetLinkage(G, LLVMGetLinkage(Cur));
1168     LLVMSetSection(G, LLVMGetSection(Cur));
1169     LLVMSetVisibility(G, LLVMGetVisibility(Cur));
1170     LLVMSetUnnamedAddress(G, LLVMGetUnnamedAddress(Cur));
1171     LLVMSetAlignment(G, LLVMGetAlignment(Cur));
1172 
1173     Next = LLVMGetNextGlobal(Cur);
1174     if (Next == nullptr) {
1175       if (Cur != End)
1176         report_fatal_error("");
1177       break;
1178     }
1179 
1180     LLVMValueRef Prev = LLVMGetPreviousGlobal(Next);
1181     if (Prev != Cur)
1182       report_fatal_error("Next.Previous global is not Current");
1183 
1184     Cur = Next;
1185   }
1186 
1187 FunClone:
1188   Begin = LLVMGetFirstFunction(Src);
1189   End = LLVMGetLastFunction(Src);
1190   if (!Begin) {
1191     if (End != nullptr)
1192       report_fatal_error("Range has an end but no beginning");
1193     goto AliasClone;
1194   }
1195 
1196   Cur = Begin;
1197   Next = nullptr;
1198   while (true) {
1199     size_t NameLen;
1200     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1201     LLVMValueRef Fun = LLVMGetNamedFunction(M, Name);
1202     if (!Fun)
1203       report_fatal_error("Function must have been declared already");
1204 
1205     if (LLVMHasPersonalityFn(Cur)) {
1206       size_t FNameLen;
1207       const char *FName = LLVMGetValueName2(LLVMGetPersonalityFn(Cur),
1208                                            &FNameLen);
1209       LLVMValueRef P = LLVMGetNamedFunction(M, FName);
1210       if (!P)
1211         report_fatal_error("Could not find personality function");
1212       LLVMSetPersonalityFn(Fun, P);
1213     }
1214 
1215     size_t NumMetadataEntries;
1216     auto *AllMetadata = LLVMGlobalCopyAllMetadata(Cur, &NumMetadataEntries);
1217     for (unsigned i = 0; i < NumMetadataEntries; ++i) {
1218       unsigned Kind = LLVMValueMetadataEntriesGetKind(AllMetadata, i);
1219       LLVMMetadataRef MD = LLVMValueMetadataEntriesGetMetadata(AllMetadata, i);
1220       LLVMGlobalSetMetadata(Fun, Kind, MD);
1221     }
1222     LLVMDisposeValueMetadataEntries(AllMetadata);
1223 
1224     FunCloner FC(Cur, Fun);
1225     FC.CloneBBs(Cur);
1226 
1227     Next = LLVMGetNextFunction(Cur);
1228     if (Next == nullptr) {
1229       if (Cur != End)
1230         report_fatal_error("Last function does not match End");
1231       break;
1232     }
1233 
1234     LLVMValueRef Prev = LLVMGetPreviousFunction(Next);
1235     if (Prev != Cur)
1236       report_fatal_error("Next.Previous function is not Current");
1237 
1238     Cur = Next;
1239   }
1240 
1241 AliasClone:
1242   Begin = LLVMGetFirstGlobalAlias(Src);
1243   End = LLVMGetLastGlobalAlias(Src);
1244   if (!Begin) {
1245     if (End != nullptr)
1246       report_fatal_error("Range has an end but no beginning");
1247     goto GlobalIFuncClone;
1248   }
1249 
1250   Cur = Begin;
1251   Next = nullptr;
1252   while (true) {
1253     size_t NameLen;
1254     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1255     LLVMValueRef Alias = LLVMGetNamedGlobalAlias(M, Name, NameLen);
1256     if (!Alias)
1257       report_fatal_error("Global alias must have been declared already");
1258 
1259     if (LLVMValueRef Aliasee = LLVMAliasGetAliasee(Cur)) {
1260       LLVMAliasSetAliasee(Alias, clone_constant(Aliasee, M));
1261     }
1262 
1263     LLVMSetLinkage(Alias, LLVMGetLinkage(Cur));
1264     LLVMSetUnnamedAddress(Alias, LLVMGetUnnamedAddress(Cur));
1265 
1266     Next = LLVMGetNextGlobalAlias(Cur);
1267     if (Next == nullptr) {
1268       if (Cur != End)
1269         report_fatal_error("Last global alias does not match End");
1270       break;
1271     }
1272 
1273     LLVMValueRef Prev = LLVMGetPreviousGlobalAlias(Next);
1274     if (Prev != Cur)
1275       report_fatal_error("Next.Previous global alias is not Current");
1276 
1277     Cur = Next;
1278   }
1279 
1280 GlobalIFuncClone:
1281   Begin = LLVMGetFirstGlobalIFunc(Src);
1282   End = LLVMGetLastGlobalIFunc(Src);
1283   if (!Begin) {
1284     if (End != nullptr)
1285       report_fatal_error("Range has an end but no beginning");
1286     goto NamedMDClone;
1287   }
1288 
1289   Cur = Begin;
1290   Next = nullptr;
1291   while (true) {
1292     size_t NameLen;
1293     const char *Name = LLVMGetValueName2(Cur, &NameLen);
1294     LLVMValueRef IFunc = LLVMGetNamedGlobalIFunc(M, Name, NameLen);
1295     if (!IFunc)
1296       report_fatal_error("Global ifunc must have been declared already");
1297 
1298     if (LLVMValueRef Resolver = LLVMGetGlobalIFuncResolver(Cur)) {
1299       LLVMSetGlobalIFuncResolver(IFunc, clone_constant(Resolver, M));
1300     }
1301 
1302     LLVMSetLinkage(IFunc, LLVMGetLinkage(Cur));
1303     LLVMSetUnnamedAddress(IFunc, LLVMGetUnnamedAddress(Cur));
1304 
1305     Next = LLVMGetNextGlobalIFunc(Cur);
1306     if (Next == nullptr) {
1307       if (Cur != End)
1308         report_fatal_error("Last global alias does not match End");
1309       break;
1310     }
1311 
1312     LLVMValueRef Prev = LLVMGetPreviousGlobalIFunc(Next);
1313     if (Prev != Cur)
1314       report_fatal_error("Next.Previous global alias is not Current");
1315 
1316     Cur = Next;
1317   }
1318 
1319 NamedMDClone:
1320   LLVMNamedMDNodeRef BeginMD = LLVMGetFirstNamedMetadata(Src);
1321   LLVMNamedMDNodeRef EndMD = LLVMGetLastNamedMetadata(Src);
1322   if (!BeginMD) {
1323     if (EndMD != nullptr)
1324       report_fatal_error("Range has an end but no beginning");
1325     return;
1326   }
1327 
1328   LLVMNamedMDNodeRef CurMD = BeginMD;
1329   LLVMNamedMDNodeRef NextMD = nullptr;
1330   while (true) {
1331     size_t NameLen;
1332     const char *Name = LLVMGetNamedMetadataName(CurMD, &NameLen);
1333     LLVMNamedMDNodeRef NamedMD = LLVMGetNamedMetadata(M, Name, NameLen);
1334     if (!NamedMD)
1335       report_fatal_error("Named MD Node must have been declared already");
1336 
1337     unsigned OperandCount = LLVMGetNamedMetadataNumOperands(Src, Name);
1338     LLVMValueRef *OperandBuf = static_cast<LLVMValueRef *>(
1339               safe_malloc(OperandCount * sizeof(LLVMValueRef)));
1340     LLVMGetNamedMetadataOperands(Src, Name, OperandBuf);
1341     for (unsigned i = 0, e = OperandCount; i != e; ++i) {
1342       LLVMAddNamedMetadataOperand(M, Name, OperandBuf[i]);
1343     }
1344     free(OperandBuf);
1345 
1346     NextMD = LLVMGetNextNamedMetadata(CurMD);
1347     if (NextMD == nullptr) {
1348       if (CurMD != EndMD)
1349         report_fatal_error("Last Named MD Node does not match End");
1350       break;
1351     }
1352 
1353     LLVMNamedMDNodeRef PrevMD = LLVMGetPreviousNamedMetadata(NextMD);
1354     if (PrevMD != CurMD)
1355       report_fatal_error("Next.Previous Named MD Node is not Current");
1356 
1357     CurMD = NextMD;
1358   }
1359 }
1360 
1361 int llvm_echo(void) {
1362   LLVMEnablePrettyStackTrace();
1363 
1364   LLVMModuleRef Src = llvm_load_module(false, true);
1365   size_t SourceFileLen;
1366   const char *SourceFileName = LLVMGetSourceFileName(Src, &SourceFileLen);
1367   size_t ModuleIdentLen;
1368   const char *ModuleName = LLVMGetModuleIdentifier(Src, &ModuleIdentLen);
1369   LLVMContextRef Ctx = LLVMContextCreate();
1370   LLVMModuleRef M = LLVMModuleCreateWithNameInContext(ModuleName, Ctx);
1371 
1372   LLVMSetSourceFileName(M, SourceFileName, SourceFileLen);
1373   LLVMSetModuleIdentifier(M, ModuleName, ModuleIdentLen);
1374 
1375   LLVMSetTarget(M, LLVMGetTarget(Src));
1376   LLVMSetModuleDataLayout(M, LLVMGetModuleDataLayout(Src));
1377   if (strcmp(LLVMGetDataLayoutStr(M), LLVMGetDataLayoutStr(Src)))
1378     report_fatal_error("Inconsistent DataLayout string representation");
1379 
1380   size_t ModuleInlineAsmLen;
1381   const char *ModuleAsm = LLVMGetModuleInlineAsm(Src, &ModuleInlineAsmLen);
1382   LLVMSetModuleInlineAsm2(M, ModuleAsm, ModuleInlineAsmLen);
1383 
1384   declare_symbols(Src, M);
1385   clone_symbols(Src, M);
1386   char *Str = LLVMPrintModuleToString(M);
1387   fputs(Str, stdout);
1388 
1389   LLVMDisposeMessage(Str);
1390   LLVMDisposeModule(Src);
1391   LLVMDisposeModule(M);
1392   LLVMContextDispose(Ctx);
1393 
1394   return 0;
1395 }
1396