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