LLVM 18.0.0git
ExecutionEngine.cpp
Go to the documentation of this file.
1//===-- ExecutionEngine.cpp - Common Implementation shared by EEs ---------===//
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 defines the common interface used by the various execution engine
10// subclasses.
11//
12// FIXME: This file needs to be updated to support scalable vectors
13//
14//===----------------------------------------------------------------------===//
15
17#include "llvm/ADT/STLExtras.h"
19#include "llvm/ADT/Statistic.h"
24#include "llvm/IR/Constants.h"
25#include "llvm/IR/DataLayout.h"
27#include "llvm/IR/Mangler.h"
28#include "llvm/IR/Module.h"
29#include "llvm/IR/Operator.h"
30#include "llvm/IR/ValueHandle.h"
32#include "llvm/Object/Archive.h"
34#include "llvm/Support/Debug.h"
40#include <cmath>
41#include <cstring>
42#include <mutex>
43using namespace llvm;
44
45#define DEBUG_TYPE "jit"
46
47STATISTIC(NumInitBytes, "Number of bytes of global vars initialized");
48STATISTIC(NumGlobals , "Number of global vars initialized");
49
50ExecutionEngine *(*ExecutionEngine::MCJITCtor)(
51 std::unique_ptr<Module> M, std::string *ErrorStr,
52 std::shared_ptr<MCJITMemoryManager> MemMgr,
53 std::shared_ptr<LegacyJITSymbolResolver> Resolver,
54 std::unique_ptr<TargetMachine> TM) = nullptr;
55
56ExecutionEngine *(*ExecutionEngine::InterpCtor)(std::unique_ptr<Module> M,
57 std::string *ErrorStr) =nullptr;
58
59void JITEventListener::anchor() {}
60
61void ObjectCache::anchor() {}
62
63void ExecutionEngine::Init(std::unique_ptr<Module> M) {
64 CompilingLazily = false;
65 GVCompilationDisabled = false;
66 SymbolSearchingDisabled = false;
67
68 // IR module verification is enabled by default in debug builds, and disabled
69 // by default in release builds.
70#ifndef NDEBUG
71 VerifyModules = true;
72#else
73 VerifyModules = false;
74#endif
75
76 assert(M && "Module is null?");
77 Modules.push_back(std::move(M));
78}
79
80ExecutionEngine::ExecutionEngine(std::unique_ptr<Module> M)
81 : DL(M->getDataLayout()), LazyFunctionCreator(nullptr) {
82 Init(std::move(M));
83}
84
86 : DL(std::move(DL)), LazyFunctionCreator(nullptr) {
87 Init(std::move(M));
88}
89
92}
93
94namespace {
95/// Helper class which uses a value handler to automatically deletes the
96/// memory block when the GlobalVariable is destroyed.
97class GVMemoryBlock final : public CallbackVH {
98 GVMemoryBlock(const GlobalVariable *GV)
99 : CallbackVH(const_cast<GlobalVariable*>(GV)) {}
100
101public:
102 /// Returns the address the GlobalVariable should be written into. The
103 /// GVMemoryBlock object prefixes that.
104 static char *Create(const GlobalVariable *GV, const DataLayout& TD) {
105 Type *ElTy = GV->getValueType();
106 size_t GVSize = (size_t)TD.getTypeAllocSize(ElTy);
107 void *RawMemory = ::operator new(
108 alignTo(sizeof(GVMemoryBlock), TD.getPreferredAlign(GV)) + GVSize);
109 new(RawMemory) GVMemoryBlock(GV);
110 return static_cast<char*>(RawMemory) + sizeof(GVMemoryBlock);
111 }
112
113 void deleted() override {
114 // We allocated with operator new and with some extra memory hanging off the
115 // end, so don't just delete this. I'm not sure if this is actually
116 // required.
117 this->~GVMemoryBlock();
118 ::operator delete(this);
119 }
120};
121} // anonymous namespace
122
124 return GVMemoryBlock::Create(GV, getDataLayout());
125}
126
127void ExecutionEngine::addObjectFile(std::unique_ptr<object::ObjectFile> O) {
128 llvm_unreachable("ExecutionEngine subclass doesn't implement addObjectFile.");
129}
130
131void
133 llvm_unreachable("ExecutionEngine subclass doesn't implement addObjectFile.");
134}
135
137 llvm_unreachable("ExecutionEngine subclass doesn't implement addArchive.");
138}
139
141 for (auto I = Modules.begin(), E = Modules.end(); I != E; ++I) {
142 Module *Found = I->get();
143 if (Found == M) {
144 I->release();
145 Modules.erase(I);
147 return true;
148 }
149 }
150 return false;
151}
152
154 for (unsigned i = 0, e = Modules.size(); i != e; ++i) {
155 Function *F = Modules[i]->getFunction(FnName);
156 if (F && !F->isDeclaration())
157 return F;
158 }
159 return nullptr;
160}
161
163 for (unsigned i = 0, e = Modules.size(); i != e; ++i) {
164 GlobalVariable *GV = Modules[i]->getGlobalVariable(Name,AllowInternal);
165 if (GV && !GV->isDeclaration())
166 return GV;
167 }
168 return nullptr;
169}
170
172 GlobalAddressMapTy::iterator I = GlobalAddressMap.find(Name);
173 uint64_t OldVal;
174
175 // FIXME: This is silly, we shouldn't end up with a mapping -> 0 in the
176 // GlobalAddressMap.
177 if (I == GlobalAddressMap.end())
178 OldVal = 0;
179 else {
180 GlobalAddressReverseMap.erase(I->second);
181 OldVal = I->second;
182 GlobalAddressMap.erase(I);
183 }
184
185 return OldVal;
186}
187
189 assert(GV->hasName() && "Global must have name.");
190
191 std::lock_guard<sys::Mutex> locked(lock);
192 SmallString<128> FullName;
193
194 const DataLayout &DL =
196 ? getDataLayout()
197 : GV->getParent()->getDataLayout();
198
199 Mangler::getNameWithPrefix(FullName, GV->getName(), DL);
200 return std::string(FullName.str());
201}
202
204 std::lock_guard<sys::Mutex> locked(lock);
206}
207
209 std::lock_guard<sys::Mutex> locked(lock);
210
211 assert(!Name.empty() && "Empty GlobalMapping symbol name!");
212
213 LLVM_DEBUG(dbgs() << "JIT: Map \'" << Name << "\' to [" << Addr << "]\n";);
214 uint64_t &CurVal = EEState.getGlobalAddressMap()[Name];
215 assert((!CurVal || !Addr) && "GlobalMapping already established!");
216 CurVal = Addr;
217
218 // If we are using the reverse mapping, add it too.
219 if (!EEState.getGlobalAddressReverseMap().empty()) {
220 std::string &V = EEState.getGlobalAddressReverseMap()[CurVal];
221 assert((!V.empty() || !Name.empty()) &&
222 "GlobalMapping already established!");
223 V = std::string(Name);
224 }
225}
226
228 std::lock_guard<sys::Mutex> locked(lock);
229
230 EEState.getGlobalAddressMap().clear();
231 EEState.getGlobalAddressReverseMap().clear();
232}
233
235 std::lock_guard<sys::Mutex> locked(lock);
236
237 for (GlobalObject &GO : M->global_objects())
238 EEState.RemoveMapping(getMangledName(&GO));
239}
240
242 void *Addr) {
243 std::lock_guard<sys::Mutex> locked(lock);
245}
246
248 std::lock_guard<sys::Mutex> locked(lock);
249
251 EEState.getGlobalAddressMap();
252
253 // Deleting from the mapping?
254 if (!Addr)
255 return EEState.RemoveMapping(Name);
256
257 uint64_t &CurVal = Map[Name];
258 uint64_t OldVal = CurVal;
259
260 if (CurVal && !EEState.getGlobalAddressReverseMap().empty())
261 EEState.getGlobalAddressReverseMap().erase(CurVal);
262 CurVal = Addr;
263
264 // If we are using the reverse mapping, add it too.
265 if (!EEState.getGlobalAddressReverseMap().empty()) {
266 std::string &V = EEState.getGlobalAddressReverseMap()[CurVal];
267 assert((!V.empty() || !Name.empty()) &&
268 "GlobalMapping already established!");
269 V = std::string(Name);
270 }
271 return OldVal;
272}
273
275 std::lock_guard<sys::Mutex> locked(lock);
276 uint64_t Address = 0;
278 EEState.getGlobalAddressMap().find(S);
279 if (I != EEState.getGlobalAddressMap().end())
280 Address = I->second;
281 return Address;
282}
283
284
286 std::lock_guard<sys::Mutex> locked(lock);
287 if (void* Address = (void *) getAddressToGlobalIfAvailable(S))
288 return Address;
289 return nullptr;
290}
291
293 std::lock_guard<sys::Mutex> locked(lock);
295}
296
298 std::lock_guard<sys::Mutex> locked(lock);
299
300 // If we haven't computed the reverse mapping yet, do so first.
301 if (EEState.getGlobalAddressReverseMap().empty()) {
303 I = EEState.getGlobalAddressMap().begin(),
304 E = EEState.getGlobalAddressMap().end(); I != E; ++I) {
305 StringRef Name = I->first();
306 uint64_t Addr = I->second;
307 EEState.getGlobalAddressReverseMap().insert(
308 std::make_pair(Addr, std::string(Name)));
309 }
310 }
311
312 std::map<uint64_t, std::string>::iterator I =
313 EEState.getGlobalAddressReverseMap().find((uint64_t) Addr);
314
315 if (I != EEState.getGlobalAddressReverseMap().end()) {
316 StringRef Name = I->second;
317 for (unsigned i = 0, e = Modules.size(); i != e; ++i)
318 if (GlobalValue *GV = Modules[i]->getNamedValue(Name))
319 return GV;
320 }
321 return nullptr;
322}
323
324namespace {
325class ArgvArray {
326 std::unique_ptr<char[]> Array;
327 std::vector<std::unique_ptr<char[]>> Values;
328public:
329 /// Turn a vector of strings into a nice argv style array of pointers to null
330 /// terminated strings.
331 void *reset(LLVMContext &C, ExecutionEngine *EE,
332 const std::vector<std::string> &InputArgv);
333};
334} // anonymous namespace
335void *ArgvArray::reset(LLVMContext &C, ExecutionEngine *EE,
336 const std::vector<std::string> &InputArgv) {
337 Values.clear(); // Free the old contents.
338 Values.reserve(InputArgv.size());
339 unsigned PtrSize = EE->getDataLayout().getPointerSize();
340 Array = std::make_unique<char[]>((InputArgv.size()+1)*PtrSize);
341
342 LLVM_DEBUG(dbgs() << "JIT: ARGV = " << (void *)Array.get() << "\n");
343 Type *SBytePtr = Type::getInt8PtrTy(C);
344
345 for (unsigned i = 0; i != InputArgv.size(); ++i) {
346 unsigned Size = InputArgv[i].size()+1;
347 auto Dest = std::make_unique<char[]>(Size);
348 LLVM_DEBUG(dbgs() << "JIT: ARGV[" << i << "] = " << (void *)Dest.get()
349 << "\n");
350
351 std::copy(InputArgv[i].begin(), InputArgv[i].end(), Dest.get());
352 Dest[Size-1] = 0;
353
354 // Endian safe: Array[i] = (PointerTy)Dest;
355 EE->StoreValueToMemory(PTOGV(Dest.get()),
356 (GenericValue*)(&Array[i*PtrSize]), SBytePtr);
357 Values.push_back(std::move(Dest));
358 }
359
360 // Null terminate it
361 EE->StoreValueToMemory(PTOGV(nullptr),
362 (GenericValue*)(&Array[InputArgv.size()*PtrSize]),
363 SBytePtr);
364 return Array.get();
365}
366
368 bool isDtors) {
369 StringRef Name(isDtors ? "llvm.global_dtors" : "llvm.global_ctors");
370 GlobalVariable *GV = module.getNamedGlobal(Name);
371
372 // If this global has internal linkage, or if it has a use, then it must be
373 // an old-style (llvmgcc3) static ctor with __main linked in and in use. If
374 // this is the case, don't execute any of the global ctors, __main will do
375 // it.
376 if (!GV || GV->isDeclaration() || GV->hasLocalLinkage()) return;
377
378 // Should be an array of '{ i32, void ()* }' structs. The first value is
379 // the init priority, which we ignore.
380 ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer());
381 if (!InitList)
382 return;
383 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) {
384 ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i));
385 if (!CS) continue;
386
387 Constant *FP = CS->getOperand(1);
388 if (FP->isNullValue())
389 continue; // Found a sentinal value, ignore.
390
391 // Strip off constant expression casts.
392 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(FP))
393 if (CE->isCast())
394 FP = CE->getOperand(0);
395
396 // Execute the ctor/dtor function!
397 if (Function *F = dyn_cast<Function>(FP))
398 runFunction(F, std::nullopt);
399
400 // FIXME: It is marginally lame that we just do nothing here if we see an
401 // entry we don't recognize. It might not be unreasonable for the verifier
402 // to not even allow this and just assert here.
403 }
404}
405
407 // Execute global ctors/dtors for each module in the program.
408 for (std::unique_ptr<Module> &M : Modules)
410}
411
412#ifndef NDEBUG
413/// isTargetNullPtr - Return whether the target pointer stored at Loc is null.
414static bool isTargetNullPtr(ExecutionEngine *EE, void *Loc) {
415 unsigned PtrSize = EE->getDataLayout().getPointerSize();
416 for (unsigned i = 0; i < PtrSize; ++i)
417 if (*(i + (uint8_t*)Loc))
418 return false;
419 return true;
420}
421#endif
422
424 const std::vector<std::string> &argv,
425 const char * const * envp) {
426 std::vector<GenericValue> GVArgs;
427 GenericValue GVArgc;
428 GVArgc.IntVal = APInt(32, argv.size());
429
430 // Check main() type
431 unsigned NumArgs = Fn->getFunctionType()->getNumParams();
432 FunctionType *FTy = Fn->getFunctionType();
433 Type *PPInt8Ty = PointerType::get(Fn->getContext(), 0);
434
435 // Check the argument types.
436 if (NumArgs > 3)
437 report_fatal_error("Invalid number of arguments of main() supplied");
438 if (NumArgs >= 3 && FTy->getParamType(2) != PPInt8Ty)
439 report_fatal_error("Invalid type for third argument of main() supplied");
440 if (NumArgs >= 2 && FTy->getParamType(1) != PPInt8Ty)
441 report_fatal_error("Invalid type for second argument of main() supplied");
442 if (NumArgs >= 1 && !FTy->getParamType(0)->isIntegerTy(32))
443 report_fatal_error("Invalid type for first argument of main() supplied");
444 if (!FTy->getReturnType()->isIntegerTy() &&
445 !FTy->getReturnType()->isVoidTy())
446 report_fatal_error("Invalid return type of main() supplied");
447
448 ArgvArray CArgv;
449 ArgvArray CEnv;
450 if (NumArgs) {
451 GVArgs.push_back(GVArgc); // Arg #0 = argc.
452 if (NumArgs > 1) {
453 // Arg #1 = argv.
454 GVArgs.push_back(PTOGV(CArgv.reset(Fn->getContext(), this, argv)));
455 assert(!isTargetNullPtr(this, GVTOP(GVArgs[1])) &&
456 "argv[0] was null after CreateArgv");
457 if (NumArgs > 2) {
458 std::vector<std::string> EnvVars;
459 for (unsigned i = 0; envp[i]; ++i)
460 EnvVars.emplace_back(envp[i]);
461 // Arg #2 = envp.
462 GVArgs.push_back(PTOGV(CEnv.reset(Fn->getContext(), this, EnvVars)));
463 }
464 }
465 }
466
467 return runFunction(Fn, GVArgs).IntVal.getZExtValue();
468}
469
471
472EngineBuilder::EngineBuilder(std::unique_ptr<Module> M)
473 : M(std::move(M)), WhichEngine(EngineKind::Either), ErrorStr(nullptr),
474 OptLevel(CodeGenOptLevel::Default), MemMgr(nullptr), Resolver(nullptr) {
475// IR module verification is enabled by default in debug builds, and disabled
476// by default in release builds.
477#ifndef NDEBUG
478 VerifyModules = true;
479#else
480 VerifyModules = false;
481#endif
482}
483
485
487 std::unique_ptr<RTDyldMemoryManager> mcjmm) {
488 auto SharedMM = std::shared_ptr<RTDyldMemoryManager>(std::move(mcjmm));
489 MemMgr = SharedMM;
490 Resolver = SharedMM;
491 return *this;
492}
493
495EngineBuilder::setMemoryManager(std::unique_ptr<MCJITMemoryManager> MM) {
496 MemMgr = std::shared_ptr<MCJITMemoryManager>(std::move(MM));
497 return *this;
498}
499
501EngineBuilder::setSymbolResolver(std::unique_ptr<LegacyJITSymbolResolver> SR) {
502 Resolver = std::shared_ptr<LegacyJITSymbolResolver>(std::move(SR));
503 return *this;
504}
505
507 std::unique_ptr<TargetMachine> TheTM(TM); // Take ownership.
508
509 // Make sure we can resolve symbols in the program as well. The zero arg
510 // to the function tells DynamicLibrary to load the program, not a library.
511 if (sys::DynamicLibrary::LoadLibraryPermanently(nullptr, ErrorStr))
512 return nullptr;
513
514 // If the user specified a memory manager but didn't specify which engine to
515 // create, we assume they only want the JIT, and we fail if they only want
516 // the interpreter.
517 if (MemMgr) {
518 if (WhichEngine & EngineKind::JIT)
519 WhichEngine = EngineKind::JIT;
520 else {
521 if (ErrorStr)
522 *ErrorStr = "Cannot create an interpreter with a memory manager.";
523 return nullptr;
524 }
525 }
526
527 // Unless the interpreter was explicitly selected or the JIT is not linked,
528 // try making a JIT.
529 if ((WhichEngine & EngineKind::JIT) && TheTM) {
530 if (!TM->getTarget().hasJIT()) {
531 errs() << "WARNING: This target JIT is not designed for the host"
532 << " you are running. If bad things happen, please choose"
533 << " a different -march switch.\n";
534 }
535
536 ExecutionEngine *EE = nullptr;
538 EE = ExecutionEngine::MCJITCtor(std::move(M), ErrorStr, std::move(MemMgr),
539 std::move(Resolver), std::move(TheTM));
540
541 if (EE) {
542 EE->setVerifyModules(VerifyModules);
543 return EE;
544 }
545 }
546
547 // If we can't make a JIT and we didn't request one specifically, try making
548 // an interpreter instead.
549 if (WhichEngine & EngineKind::Interpreter) {
551 return ExecutionEngine::InterpCtor(std::move(M), ErrorStr);
552 if (ErrorStr)
553 *ErrorStr = "Interpreter has not been linked in.";
554 return nullptr;
555 }
556
557 if ((WhichEngine & EngineKind::JIT) && !ExecutionEngine::MCJITCtor) {
558 if (ErrorStr)
559 *ErrorStr = "JIT has not been linked in.";
560 }
561
562 return nullptr;
563}
564
566 if (Function *F = const_cast<Function*>(dyn_cast<Function>(GV)))
567 return getPointerToFunction(F);
568
569 std::lock_guard<sys::Mutex> locked(lock);
570 if (void* P = getPointerToGlobalIfAvailable(GV))
571 return P;
572
573 // Global variable might have been added since interpreter started.
574 if (GlobalVariable *GVar =
575 const_cast<GlobalVariable *>(dyn_cast<GlobalVariable>(GV)))
576 emitGlobalVariable(GVar);
577 else
578 llvm_unreachable("Global hasn't had an address allocated yet!");
579
581}
582
583/// Converts a Constant* into a GenericValue, including handling of
584/// ConstantExpr values.
586 // If its undefined, return the garbage.
587 if (isa<UndefValue>(C)) {
588 GenericValue Result;
589 switch (C->getType()->getTypeID()) {
590 default:
591 break;
594 case Type::FP128TyID:
596 // Although the value is undefined, we still have to construct an APInt
597 // with the correct bit width.
598 Result.IntVal = APInt(C->getType()->getPrimitiveSizeInBits(), 0);
599 break;
600 case Type::StructTyID: {
601 // if the whole struct is 'undef' just reserve memory for the value.
602 if(StructType *STy = dyn_cast<StructType>(C->getType())) {
603 unsigned int elemNum = STy->getNumElements();
604 Result.AggregateVal.resize(elemNum);
605 for (unsigned int i = 0; i < elemNum; ++i) {
606 Type *ElemTy = STy->getElementType(i);
607 if (ElemTy->isIntegerTy())
608 Result.AggregateVal[i].IntVal =
609 APInt(ElemTy->getPrimitiveSizeInBits(), 0);
610 else if (ElemTy->isAggregateType()) {
611 const Constant *ElemUndef = UndefValue::get(ElemTy);
612 Result.AggregateVal[i] = getConstantValue(ElemUndef);
613 }
614 }
615 }
616 }
617 break;
620 "Scalable vector support not yet implemented in ExecutionEngine");
622 // if the whole vector is 'undef' just reserve memory for the value.
623 auto *VTy = cast<FixedVectorType>(C->getType());
624 Type *ElemTy = VTy->getElementType();
625 unsigned int elemNum = VTy->getNumElements();
626 Result.AggregateVal.resize(elemNum);
627 if (ElemTy->isIntegerTy())
628 for (unsigned int i = 0; i < elemNum; ++i)
629 Result.AggregateVal[i].IntVal =
630 APInt(ElemTy->getPrimitiveSizeInBits(), 0);
631 break;
632 }
633 return Result;
634 }
635
636 // Otherwise, if the value is a ConstantExpr...
637 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
638 Constant *Op0 = CE->getOperand(0);
639 switch (CE->getOpcode()) {
640 case Instruction::GetElementPtr: {
641 // Compute the index
642 GenericValue Result = getConstantValue(Op0);
644 cast<GEPOperator>(CE)->accumulateConstantOffset(DL, Offset);
645
646 char* tmp = (char*) Result.PointerVal;
647 Result = PTOGV(tmp + Offset.getSExtValue());
648 return Result;
649 }
650 case Instruction::Trunc: {
652 uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
653 GV.IntVal = GV.IntVal.trunc(BitWidth);
654 return GV;
655 }
656 case Instruction::ZExt: {
658 uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
659 GV.IntVal = GV.IntVal.zext(BitWidth);
660 return GV;
661 }
662 case Instruction::SExt: {
664 uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
665 GV.IntVal = GV.IntVal.sext(BitWidth);
666 return GV;
667 }
668 case Instruction::FPTrunc: {
669 // FIXME long double
671 GV.FloatVal = float(GV.DoubleVal);
672 return GV;
673 }
674 case Instruction::FPExt:{
675 // FIXME long double
677 GV.DoubleVal = double(GV.FloatVal);
678 return GV;
679 }
680 case Instruction::UIToFP: {
682 if (CE->getType()->isFloatTy())
683 GV.FloatVal = float(GV.IntVal.roundToDouble());
684 else if (CE->getType()->isDoubleTy())
686 else if (CE->getType()->isX86_FP80Ty()) {
688 (void)apf.convertFromAPInt(GV.IntVal,
689 false,
691 GV.IntVal = apf.bitcastToAPInt();
692 }
693 return GV;
694 }
695 case Instruction::SIToFP: {
697 if (CE->getType()->isFloatTy())
698 GV.FloatVal = float(GV.IntVal.signedRoundToDouble());
699 else if (CE->getType()->isDoubleTy())
701 else if (CE->getType()->isX86_FP80Ty()) {
703 (void)apf.convertFromAPInt(GV.IntVal,
704 true,
706 GV.IntVal = apf.bitcastToAPInt();
707 }
708 return GV;
709 }
710 case Instruction::FPToUI: // double->APInt conversion handles sign
711 case Instruction::FPToSI: {
713 uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
714 if (Op0->getType()->isFloatTy())
716 else if (Op0->getType()->isDoubleTy())
718 else if (Op0->getType()->isX86_FP80Ty()) {
720 uint64_t v;
721 bool ignored;
723 CE->getOpcode()==Instruction::FPToSI,
725 GV.IntVal = v; // endian?
726 }
727 return GV;
728 }
729 case Instruction::PtrToInt: {
731 uint32_t PtrWidth = DL.getTypeSizeInBits(Op0->getType());
732 assert(PtrWidth <= 64 && "Bad pointer width");
733 GV.IntVal = APInt(PtrWidth, uintptr_t(GV.PointerVal));
734 uint32_t IntWidth = DL.getTypeSizeInBits(CE->getType());
735 GV.IntVal = GV.IntVal.zextOrTrunc(IntWidth);
736 return GV;
737 }
738 case Instruction::IntToPtr: {
740 uint32_t PtrWidth = DL.getTypeSizeInBits(CE->getType());
741 GV.IntVal = GV.IntVal.zextOrTrunc(PtrWidth);
742 assert(GV.IntVal.getBitWidth() <= 64 && "Bad pointer width");
743 GV.PointerVal = PointerTy(uintptr_t(GV.IntVal.getZExtValue()));
744 return GV;
745 }
746 case Instruction::BitCast: {
748 Type* DestTy = CE->getType();
749 switch (Op0->getType()->getTypeID()) {
750 default: llvm_unreachable("Invalid bitcast operand");
752 assert(DestTy->isFloatingPointTy() && "invalid bitcast");
753 if (DestTy->isFloatTy())
754 GV.FloatVal = GV.IntVal.bitsToFloat();
755 else if (DestTy->isDoubleTy())
756 GV.DoubleVal = GV.IntVal.bitsToDouble();
757 break;
758 case Type::FloatTyID:
759 assert(DestTy->isIntegerTy(32) && "Invalid bitcast");
761 break;
762 case Type::DoubleTyID:
763 assert(DestTy->isIntegerTy(64) && "Invalid bitcast");
765 break;
767 assert(DestTy->isPointerTy() && "Invalid bitcast");
768 break; // getConstantValue(Op0) above already converted it
769 }
770 return GV;
771 }
772 case Instruction::Add:
773 case Instruction::FAdd:
774 case Instruction::Sub:
775 case Instruction::FSub:
776 case Instruction::Mul:
777 case Instruction::FMul:
778 case Instruction::UDiv:
779 case Instruction::SDiv:
780 case Instruction::URem:
781 case Instruction::SRem:
782 case Instruction::And:
783 case Instruction::Or:
784 case Instruction::Xor: {
786 GenericValue RHS = getConstantValue(CE->getOperand(1));
787 GenericValue GV;
788 switch (CE->getOperand(0)->getType()->getTypeID()) {
789 default: llvm_unreachable("Bad add type!");
791 switch (CE->getOpcode()) {
792 default: llvm_unreachable("Invalid integer opcode");
793 case Instruction::Add: GV.IntVal = LHS.IntVal + RHS.IntVal; break;
794 case Instruction::Sub: GV.IntVal = LHS.IntVal - RHS.IntVal; break;
795 case Instruction::Mul: GV.IntVal = LHS.IntVal * RHS.IntVal; break;
796 case Instruction::UDiv:GV.IntVal = LHS.IntVal.udiv(RHS.IntVal); break;
797 case Instruction::SDiv:GV.IntVal = LHS.IntVal.sdiv(RHS.IntVal); break;
798 case Instruction::URem:GV.IntVal = LHS.IntVal.urem(RHS.IntVal); break;
799 case Instruction::SRem:GV.IntVal = LHS.IntVal.srem(RHS.IntVal); break;
800 case Instruction::And: GV.IntVal = LHS.IntVal & RHS.IntVal; break;
801 case Instruction::Or: GV.IntVal = LHS.IntVal | RHS.IntVal; break;
802 case Instruction::Xor: GV.IntVal = LHS.IntVal ^ RHS.IntVal; break;
803 }
804 break;
805 case Type::FloatTyID:
806 switch (CE->getOpcode()) {
807 default: llvm_unreachable("Invalid float opcode");
808 case Instruction::FAdd:
809 GV.FloatVal = LHS.FloatVal + RHS.FloatVal; break;
810 case Instruction::FSub:
811 GV.FloatVal = LHS.FloatVal - RHS.FloatVal; break;
812 case Instruction::FMul:
813 GV.FloatVal = LHS.FloatVal * RHS.FloatVal; break;
814 case Instruction::FDiv:
815 GV.FloatVal = LHS.FloatVal / RHS.FloatVal; break;
816 case Instruction::FRem:
817 GV.FloatVal = std::fmod(LHS.FloatVal,RHS.FloatVal); break;
818 }
819 break;
820 case Type::DoubleTyID:
821 switch (CE->getOpcode()) {
822 default: llvm_unreachable("Invalid double opcode");
823 case Instruction::FAdd:
824 GV.DoubleVal = LHS.DoubleVal + RHS.DoubleVal; break;
825 case Instruction::FSub:
826 GV.DoubleVal = LHS.DoubleVal - RHS.DoubleVal; break;
827 case Instruction::FMul:
828 GV.DoubleVal = LHS.DoubleVal * RHS.DoubleVal; break;
829 case Instruction::FDiv:
830 GV.DoubleVal = LHS.DoubleVal / RHS.DoubleVal; break;
831 case Instruction::FRem:
832 GV.DoubleVal = std::fmod(LHS.DoubleVal,RHS.DoubleVal); break;
833 }
834 break;
837 case Type::FP128TyID: {
838 const fltSemantics &Sem = CE->getOperand(0)->getType()->getFltSemantics();
839 APFloat apfLHS = APFloat(Sem, LHS.IntVal);
840 switch (CE->getOpcode()) {
841 default: llvm_unreachable("Invalid long double opcode");
842 case Instruction::FAdd:
843 apfLHS.add(APFloat(Sem, RHS.IntVal), APFloat::rmNearestTiesToEven);
844 GV.IntVal = apfLHS.bitcastToAPInt();
845 break;
846 case Instruction::FSub:
847 apfLHS.subtract(APFloat(Sem, RHS.IntVal),
849 GV.IntVal = apfLHS.bitcastToAPInt();
850 break;
851 case Instruction::FMul:
852 apfLHS.multiply(APFloat(Sem, RHS.IntVal),
854 GV.IntVal = apfLHS.bitcastToAPInt();
855 break;
856 case Instruction::FDiv:
857 apfLHS.divide(APFloat(Sem, RHS.IntVal),
859 GV.IntVal = apfLHS.bitcastToAPInt();
860 break;
861 case Instruction::FRem:
862 apfLHS.mod(APFloat(Sem, RHS.IntVal));
863 GV.IntVal = apfLHS.bitcastToAPInt();
864 break;
865 }
866 }
867 break;
868 }
869 return GV;
870 }
871 default:
872 break;
873 }
874
877 OS << "ConstantExpr not handled: " << *CE;
878 report_fatal_error(OS.str());
879 }
880
881 if (auto *TETy = dyn_cast<TargetExtType>(C->getType())) {
882 assert(TETy->hasProperty(TargetExtType::HasZeroInit) && C->isNullValue() &&
883 "TargetExtType only supports null constant value");
884 C = Constant::getNullValue(TETy->getLayoutType());
885 }
886
887 // Otherwise, we have a simple constant.
888 GenericValue Result;
889 switch (C->getType()->getTypeID()) {
890 case Type::FloatTyID:
891 Result.FloatVal = cast<ConstantFP>(C)->getValueAPF().convertToFloat();
892 break;
893 case Type::DoubleTyID:
894 Result.DoubleVal = cast<ConstantFP>(C)->getValueAPF().convertToDouble();
895 break;
897 case Type::FP128TyID:
899 Result.IntVal = cast <ConstantFP>(C)->getValueAPF().bitcastToAPInt();
900 break;
902 Result.IntVal = cast<ConstantInt>(C)->getValue();
903 break;
905 while (auto *A = dyn_cast<GlobalAlias>(C)) {
906 C = A->getAliasee();
907 }
908 if (isa<ConstantPointerNull>(C))
909 Result.PointerVal = nullptr;
910 else if (const Function *F = dyn_cast<Function>(C))
911 Result = PTOGV(getPointerToFunctionOrStub(const_cast<Function*>(F)));
912 else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(C))
913 Result = PTOGV(getOrEmitGlobalVariable(const_cast<GlobalVariable*>(GV)));
914 else
915 llvm_unreachable("Unknown constant pointer type!");
916 break;
919 "Scalable vector support not yet implemented in ExecutionEngine");
921 unsigned elemNum;
922 Type* ElemTy;
923 const ConstantDataVector *CDV = dyn_cast<ConstantDataVector>(C);
924 const ConstantVector *CV = dyn_cast<ConstantVector>(C);
925 const ConstantAggregateZero *CAZ = dyn_cast<ConstantAggregateZero>(C);
926
927 if (CDV) {
928 elemNum = CDV->getNumElements();
929 ElemTy = CDV->getElementType();
930 } else if (CV || CAZ) {
931 auto *VTy = cast<FixedVectorType>(C->getType());
932 elemNum = VTy->getNumElements();
933 ElemTy = VTy->getElementType();
934 } else {
935 llvm_unreachable("Unknown constant vector type!");
936 }
937
938 Result.AggregateVal.resize(elemNum);
939 // Check if vector holds floats.
940 if(ElemTy->isFloatTy()) {
941 if (CAZ) {
942 GenericValue floatZero;
943 floatZero.FloatVal = 0.f;
944 std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),
945 floatZero);
946 break;
947 }
948 if(CV) {
949 for (unsigned i = 0; i < elemNum; ++i)
950 if (!isa<UndefValue>(CV->getOperand(i)))
951 Result.AggregateVal[i].FloatVal = cast<ConstantFP>(
952 CV->getOperand(i))->getValueAPF().convertToFloat();
953 break;
954 }
955 if(CDV)
956 for (unsigned i = 0; i < elemNum; ++i)
957 Result.AggregateVal[i].FloatVal = CDV->getElementAsFloat(i);
958
959 break;
960 }
961 // Check if vector holds doubles.
962 if (ElemTy->isDoubleTy()) {
963 if (CAZ) {
964 GenericValue doubleZero;
965 doubleZero.DoubleVal = 0.0;
966 std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),
967 doubleZero);
968 break;
969 }
970 if(CV) {
971 for (unsigned i = 0; i < elemNum; ++i)
972 if (!isa<UndefValue>(CV->getOperand(i)))
973 Result.AggregateVal[i].DoubleVal = cast<ConstantFP>(
974 CV->getOperand(i))->getValueAPF().convertToDouble();
975 break;
976 }
977 if(CDV)
978 for (unsigned i = 0; i < elemNum; ++i)
979 Result.AggregateVal[i].DoubleVal = CDV->getElementAsDouble(i);
980
981 break;
982 }
983 // Check if vector holds integers.
984 if (ElemTy->isIntegerTy()) {
985 if (CAZ) {
986 GenericValue intZero;
987 intZero.IntVal = APInt(ElemTy->getScalarSizeInBits(), 0ull);
988 std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),
989 intZero);
990 break;
991 }
992 if(CV) {
993 for (unsigned i = 0; i < elemNum; ++i)
994 if (!isa<UndefValue>(CV->getOperand(i)))
995 Result.AggregateVal[i].IntVal = cast<ConstantInt>(
996 CV->getOperand(i))->getValue();
997 else {
998 Result.AggregateVal[i].IntVal =
1000 }
1001 break;
1002 }
1003 if(CDV)
1004 for (unsigned i = 0; i < elemNum; ++i)
1005 Result.AggregateVal[i].IntVal = APInt(
1007 CDV->getElementAsInteger(i));
1008
1009 break;
1010 }
1011 llvm_unreachable("Unknown constant pointer type!");
1012 } break;
1013
1014 default:
1015 SmallString<256> Msg;
1017 OS << "ERROR: Constant unimplemented for type: " << *C->getType();
1018 report_fatal_error(OS.str());
1019 }
1020
1021 return Result;
1022}
1023
1025 GenericValue *Ptr, Type *Ty) {
1026 // It is safe to treat TargetExtType as its layout type since the underlying
1027 // bits are only copied and are not inspected.
1028 if (auto *TETy = dyn_cast<TargetExtType>(Ty))
1029 Ty = TETy->getLayoutType();
1030
1031 const unsigned StoreBytes = getDataLayout().getTypeStoreSize(Ty);
1032
1033 switch (Ty->getTypeID()) {
1034 default:
1035 dbgs() << "Cannot store value of type " << *Ty << "!\n";
1036 break;
1037 case Type::IntegerTyID:
1038 StoreIntToMemory(Val.IntVal, (uint8_t*)Ptr, StoreBytes);
1039 break;
1040 case Type::FloatTyID:
1041 *((float*)Ptr) = Val.FloatVal;
1042 break;
1043 case Type::DoubleTyID:
1044 *((double*)Ptr) = Val.DoubleVal;
1045 break;
1046 case Type::X86_FP80TyID:
1047 memcpy(Ptr, Val.IntVal.getRawData(), 10);
1048 break;
1049 case Type::PointerTyID:
1050 // Ensure 64 bit target pointers are fully initialized on 32 bit hosts.
1051 if (StoreBytes != sizeof(PointerTy))
1052 memset(&(Ptr->PointerVal), 0, StoreBytes);
1053
1054 *((PointerTy*)Ptr) = Val.PointerVal;
1055 break;
1058 for (unsigned i = 0; i < Val.AggregateVal.size(); ++i) {
1059 if (cast<VectorType>(Ty)->getElementType()->isDoubleTy())
1060 *(((double*)Ptr)+i) = Val.AggregateVal[i].DoubleVal;
1061 if (cast<VectorType>(Ty)->getElementType()->isFloatTy())
1062 *(((float*)Ptr)+i) = Val.AggregateVal[i].FloatVal;
1063 if (cast<VectorType>(Ty)->getElementType()->isIntegerTy()) {
1064 unsigned numOfBytes =(Val.AggregateVal[i].IntVal.getBitWidth()+7)/8;
1065 StoreIntToMemory(Val.AggregateVal[i].IntVal,
1066 (uint8_t*)Ptr + numOfBytes*i, numOfBytes);
1067 }
1068 }
1069 break;
1070 }
1071
1072 if (sys::IsLittleEndianHost != getDataLayout().isLittleEndian())
1073 // Host and target are different endian - reverse the stored bytes.
1074 std::reverse((uint8_t*)Ptr, StoreBytes + (uint8_t*)Ptr);
1075}
1076
1077/// FIXME: document
1078///
1081 Type *Ty) {
1082 if (auto *TETy = dyn_cast<TargetExtType>(Ty))
1083 Ty = TETy->getLayoutType();
1084
1085 const unsigned LoadBytes = getDataLayout().getTypeStoreSize(Ty);
1086
1087 switch (Ty->getTypeID()) {
1088 case Type::IntegerTyID:
1089 // An APInt with all words initially zero.
1090 Result.IntVal = APInt(cast<IntegerType>(Ty)->getBitWidth(), 0);
1091 LoadIntFromMemory(Result.IntVal, (uint8_t*)Ptr, LoadBytes);
1092 break;
1093 case Type::FloatTyID:
1094 Result.FloatVal = *((float*)Ptr);
1095 break;
1096 case Type::DoubleTyID:
1097 Result.DoubleVal = *((double*)Ptr);
1098 break;
1099 case Type::PointerTyID:
1100 Result.PointerVal = *((PointerTy*)Ptr);
1101 break;
1102 case Type::X86_FP80TyID: {
1103 // This is endian dependent, but it will only work on x86 anyway.
1104 // FIXME: Will not trap if loading a signaling NaN.
1105 uint64_t y[2];
1106 memcpy(y, Ptr, 10);
1107 Result.IntVal = APInt(80, y);
1108 break;
1109 }
1112 "Scalable vector support not yet implemented in ExecutionEngine");
1113 case Type::FixedVectorTyID: {
1114 auto *VT = cast<FixedVectorType>(Ty);
1115 Type *ElemT = VT->getElementType();
1116 const unsigned numElems = VT->getNumElements();
1117 if (ElemT->isFloatTy()) {
1118 Result.AggregateVal.resize(numElems);
1119 for (unsigned i = 0; i < numElems; ++i)
1120 Result.AggregateVal[i].FloatVal = *((float*)Ptr+i);
1121 }
1122 if (ElemT->isDoubleTy()) {
1123 Result.AggregateVal.resize(numElems);
1124 for (unsigned i = 0; i < numElems; ++i)
1125 Result.AggregateVal[i].DoubleVal = *((double*)Ptr+i);
1126 }
1127 if (ElemT->isIntegerTy()) {
1128 GenericValue intZero;
1129 const unsigned elemBitWidth = cast<IntegerType>(ElemT)->getBitWidth();
1130 intZero.IntVal = APInt(elemBitWidth, 0);
1131 Result.AggregateVal.resize(numElems, intZero);
1132 for (unsigned i = 0; i < numElems; ++i)
1133 LoadIntFromMemory(Result.AggregateVal[i].IntVal,
1134 (uint8_t*)Ptr+((elemBitWidth+7)/8)*i, (elemBitWidth+7)/8);
1135 }
1136 break;
1137 }
1138 default:
1139 SmallString<256> Msg;
1141 OS << "Cannot load value of type " << *Ty << "!";
1142 report_fatal_error(OS.str());
1143 }
1144}
1145
1147 LLVM_DEBUG(dbgs() << "JIT: Initializing " << Addr << " ");
1148 LLVM_DEBUG(Init->dump());
1149 if (isa<UndefValue>(Init))
1150 return;
1151
1152 if (const ConstantVector *CP = dyn_cast<ConstantVector>(Init)) {
1153 unsigned ElementSize =
1154 getDataLayout().getTypeAllocSize(CP->getType()->getElementType());
1155 for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i)
1156 InitializeMemory(CP->getOperand(i), (char*)Addr+i*ElementSize);
1157 return;
1158 }
1159
1160 if (isa<ConstantAggregateZero>(Init)) {
1161 memset(Addr, 0, (size_t)getDataLayout().getTypeAllocSize(Init->getType()));
1162 return;
1163 }
1164
1165 if (const ConstantArray *CPA = dyn_cast<ConstantArray>(Init)) {
1166 unsigned ElementSize =
1167 getDataLayout().getTypeAllocSize(CPA->getType()->getElementType());
1168 for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i)
1169 InitializeMemory(CPA->getOperand(i), (char*)Addr+i*ElementSize);
1170 return;
1171 }
1172
1173 if (const ConstantStruct *CPS = dyn_cast<ConstantStruct>(Init)) {
1174 const StructLayout *SL =
1175 getDataLayout().getStructLayout(cast<StructType>(CPS->getType()));
1176 for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i)
1177 InitializeMemory(CPS->getOperand(i), (char*)Addr+SL->getElementOffset(i));
1178 return;
1179 }
1180
1181 if (const ConstantDataSequential *CDS =
1182 dyn_cast<ConstantDataSequential>(Init)) {
1183 // CDS is already laid out in host memory order.
1184 StringRef Data = CDS->getRawDataValues();
1185 memcpy(Addr, Data.data(), Data.size());
1186 return;
1187 }
1188
1189 if (Init->getType()->isFirstClassType()) {
1191 StoreValueToMemory(Val, (GenericValue*)Addr, Init->getType());
1192 return;
1193 }
1194
1195 LLVM_DEBUG(dbgs() << "Bad Type: " << *Init->getType() << "\n");
1196 llvm_unreachable("Unknown constant type to initialize memory with!");
1197}
1198
1199/// EmitGlobals - Emit all of the global variables to memory, storing their
1200/// addresses into GlobalAddress. This must make sure to copy the contents of
1201/// their initializers into the memory.
1203 // Loop over all of the global variables in the program, allocating the memory
1204 // to hold them. If there is more than one module, do a prepass over globals
1205 // to figure out how the different modules should link together.
1206 std::map<std::pair<std::string, Type*>,
1207 const GlobalValue*> LinkedGlobalsMap;
1208
1209 if (Modules.size() != 1) {
1210 for (unsigned m = 0, e = Modules.size(); m != e; ++m) {
1211 Module &M = *Modules[m];
1212 for (const auto &GV : M.globals()) {
1213 if (GV.hasLocalLinkage() || GV.isDeclaration() ||
1214 GV.hasAppendingLinkage() || !GV.hasName())
1215 continue;// Ignore external globals and globals with internal linkage.
1216
1217 const GlobalValue *&GVEntry = LinkedGlobalsMap[std::make_pair(
1218 std::string(GV.getName()), GV.getType())];
1219
1220 // If this is the first time we've seen this global, it is the canonical
1221 // version.
1222 if (!GVEntry) {
1223 GVEntry = &GV;
1224 continue;
1225 }
1226
1227 // If the existing global is strong, never replace it.
1228 if (GVEntry->hasExternalLinkage())
1229 continue;
1230
1231 // Otherwise, we know it's linkonce/weak, replace it if this is a strong
1232 // symbol. FIXME is this right for common?
1233 if (GV.hasExternalLinkage() || GVEntry->hasExternalWeakLinkage())
1234 GVEntry = &GV;
1235 }
1236 }
1237 }
1238
1239 std::vector<const GlobalValue*> NonCanonicalGlobals;
1240 for (unsigned m = 0, e = Modules.size(); m != e; ++m) {
1241 Module &M = *Modules[m];
1242 for (const auto &GV : M.globals()) {
1243 // In the multi-module case, see what this global maps to.
1244 if (!LinkedGlobalsMap.empty()) {
1245 if (const GlobalValue *GVEntry = LinkedGlobalsMap[std::make_pair(
1246 std::string(GV.getName()), GV.getType())]) {
1247 // If something else is the canonical global, ignore this one.
1248 if (GVEntry != &GV) {
1249 NonCanonicalGlobals.push_back(&GV);
1250 continue;
1251 }
1252 }
1253 }
1254
1255 if (!GV.isDeclaration()) {
1257 } else {
1258 // External variable reference. Try to use the dynamic loader to
1259 // get a pointer to it.
1261 std::string(GV.getName())))
1262 addGlobalMapping(&GV, SymAddr);
1263 else {
1264 report_fatal_error("Could not resolve external global address: "
1265 +GV.getName());
1266 }
1267 }
1268 }
1269
1270 // If there are multiple modules, map the non-canonical globals to their
1271 // canonical location.
1272 if (!NonCanonicalGlobals.empty()) {
1273 for (const GlobalValue *GV : NonCanonicalGlobals) {
1274 const GlobalValue *CGV = LinkedGlobalsMap[std::make_pair(
1275 std::string(GV->getName()), GV->getType())];
1277 assert(Ptr && "Canonical global wasn't codegen'd!");
1278 addGlobalMapping(GV, Ptr);
1279 }
1280 }
1281
1282 // Now that all of the globals are set up in memory, loop through them all
1283 // and initialize their contents.
1284 for (const auto &GV : M.globals()) {
1285 if (!GV.isDeclaration()) {
1286 if (!LinkedGlobalsMap.empty()) {
1287 if (const GlobalValue *GVEntry = LinkedGlobalsMap[std::make_pair(
1288 std::string(GV.getName()), GV.getType())])
1289 if (GVEntry != &GV) // Not the canonical variable.
1290 continue;
1291 }
1292 emitGlobalVariable(&GV);
1293 }
1294 }
1295 }
1296}
1297
1298// EmitGlobalVariable - This method emits the specified global variable to the
1299// address specified in GlobalAddresses, or allocates new memory if it's not
1300// already in the map.
1302 void *GA = getPointerToGlobalIfAvailable(GV);
1303
1304 if (!GA) {
1305 // If it's not already specified, allocate memory for the global.
1306 GA = getMemoryForGV(GV);
1307
1308 // If we failed to allocate memory for this global, return.
1309 if (!GA) return;
1310
1311 addGlobalMapping(GV, GA);
1312 }
1313
1314 // Don't initialize if it's thread local, let the client do it.
1315 if (!GV->isThreadLocal())
1317
1318 Type *ElTy = GV->getValueType();
1319 size_t GVSize = (size_t)getDataLayout().getTypeAllocSize(ElTy);
1320 NumInitBytes += (unsigned)GVSize;
1321 ++NumGlobals;
1322}
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Looks at all the uses of the given value Returns the Liveness deduced from the uses of this value Adds all uses that cause the result to be MaybeLive to MaybeLiveRetUses If the result is MaybeLiveUses might be modified but its content should be ignored(since it might not be complete). DeadArgumentEliminationPass
#define LLVM_DEBUG(X)
Definition: Debug.h:101
uint64_t Addr
std::string Name
uint64_t Size
static bool isTargetNullPtr(ExecutionEngine *EE, void *Loc)
isTargetNullPtr - Return whether the target pointer stored at Loc is null.
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
Module.h This file contains the declarations for the Module class.
#define P(N)
const char LLVMTargetMachineRef TM
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file contains some templates that are useful if you are working with the STL at all.
raw_pwrite_stream & OS
This file defines the SmallString class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
Definition: Statistic.h:167
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type.
Value * RHS
Value * LHS
opStatus divide(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:1067
opStatus subtract(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:1049
opStatus add(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:1040
opStatus convertFromAPInt(const APInt &Input, bool IsSigned, roundingMode RM)
Definition: APFloat.h:1191
opStatus multiply(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:1058
APInt bitcastToAPInt() const
Definition: APFloat.h:1208
opStatus convertToInteger(MutableArrayRef< integerPart > Input, unsigned int Width, bool IsSigned, roundingMode RM, bool *IsExact) const
Definition: APFloat.h:1183
opStatus mod(const APFloat &RHS)
Definition: APFloat.h:1085
static APFloat getZero(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative Zero.
Definition: APFloat.h:955
Class for arbitrary precision integers.
Definition: APInt.h:76
APInt zext(unsigned width) const
Zero extend to a new width.
Definition: APInt.cpp:981
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1485
APInt zextOrTrunc(unsigned width) const
Zero extend or truncate to width.
Definition: APInt.cpp:1002
APInt trunc(unsigned width) const
Truncate to new width.
Definition: APInt.cpp:906
static APInt floatToBits(float V)
Converts a float to APInt bits.
Definition: APInt.h:1687
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1433
double signedRoundToDouble() const
Converts this signed APInt to a double value.
Definition: APInt.h:1657
float bitsToFloat() const
Converts APInt bits to a float.
Definition: APInt.h:1671
static APInt doubleToBits(double V)
Converts a double to APInt bits.
Definition: APInt.h:1679
APInt sext(unsigned width) const
Sign extend to a new width.
Definition: APInt.cpp:954
double bitsToDouble() const
Converts APInt bits to a double.
Definition: APInt.h:1664
const uint64_t * getRawData() const
This function returns a pointer to the internal storage of the APInt.
Definition: APInt.h:547
double roundToDouble(bool isSigned) const
Converts this APInt to a double value.
Definition: APInt.cpp:849
Value handle with callbacks on RAUW and destruction.
Definition: ValueHandle.h:383
All zero aggregate value.
Definition: Constants.h:335
ConstantArray - Constant Array Declarations.
Definition: Constants.h:408
ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...
Definition: Constants.h:568
double getElementAsDouble(unsigned i) const
If this is an sequential container of doubles, return the specified element as a double.
Definition: Constants.cpp:3093
float getElementAsFloat(unsigned i) const
If this is an sequential container of floats, return the specified element as a float.
Definition: Constants.cpp:3087
uint64_t getElementAsInteger(unsigned i) const
If this is a sequential container of integers (of any size), return the specified element in the low ...
Definition: Constants.cpp:3014
unsigned getNumElements() const
Return the number of elements in the array or vector.
Definition: Constants.cpp:2757
Type * getElementType() const
Return the element type of the array/vector.
Definition: Constants.cpp:2731
A vector constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
Definition: Constants.h:751
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:997
Constant Vector Declarations.
Definition: Constants.h:492
This is an important base class in LLVM.
Definition: Constant.h:41
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Definition: Constants.cpp:356
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
unsigned getPointerSizeInBits(unsigned AS=0) const
Layout pointer size, in bits FIXME: The defaults need to be removed once all of the backends/clients ...
Definition: DataLayout.h:410
bool isDefault() const
Test if the DataLayout was constructed from an empty string.
Definition: DataLayout.h:251
const StructLayout * getStructLayout(StructType *Ty) const
Returns a StructLayout object, indicating the alignment of the struct, its size, and the offsets of i...
Definition: DataLayout.cpp:718
TypeSize getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition: DataLayout.h:504
Align getPreferredAlign(const GlobalVariable *GV) const
Returns the preferred alignment of the specified global.
unsigned getPointerSize(unsigned AS=0) const
Layout pointer size in bytes, rounded up to a whole number of bytes.
Definition: DataLayout.cpp:748
TypeSize getTypeSizeInBits(Type *Ty) const
Size examples:
Definition: DataLayout.h:672
TypeSize getTypeStoreSize(Type *Ty) const
Returns the maximum number of bytes that may be overwritten by storing the specified type.
Definition: DataLayout.h:472
Builder class for ExecutionEngines.
EngineBuilder & setMCJITMemoryManager(std::unique_ptr< RTDyldMemoryManager > mcjmm)
setMCJITMemoryManager - Sets the MCJIT memory manager to use.
EngineBuilder()
Default constructor for EngineBuilder.
EngineBuilder & setSymbolResolver(std::unique_ptr< LegacyJITSymbolResolver > SR)
EngineBuilder & setMemoryManager(std::unique_ptr< MCJITMemoryManager > MM)
ExecutionEngine * create()
std::map< uint64_t, std::string > & getGlobalAddressReverseMap()
uint64_t RemoveMapping(StringRef Name)
Erase an entry from the mapping table.
GlobalAddressMapTy & getGlobalAddressMap()
Abstract interface for implementation execution of LLVM modules, designed to support both interpreter...
void setVerifyModules(bool Verify)
Enable/Disable IR module verification.
void StoreValueToMemory(const GenericValue &Val, GenericValue *Ptr, Type *Ty)
StoreValueToMemory - Stores the data in Val of type Ty at address Ptr.
GenericValue getConstantValue(const Constant *C)
Converts a Constant* into a GenericValue, including handling of ConstantExpr values.
const DataLayout & getDataLayout() const
void * getPointerToGlobalIfAvailable(StringRef S)
getPointerToGlobalIfAvailable - This returns the address of the specified global value if it is has a...
void clearAllGlobalMappings()
clearAllGlobalMappings - Clear all global mappings and start over again, for use in dynamic compilati...
virtual void addArchive(object::OwningBinary< object::Archive > A)
addArchive - Add an Archive to the execution engine.
void InitializeMemory(const Constant *Init, void *Addr)
virtual void * getPointerToFunctionOrStub(Function *F)
getPointerToFunctionOrStub - If the specified function has been code-gen'd, return a pointer to the f...
std::string getMangledName(const GlobalValue *GV)
getMangledName - Get mangled name.
virtual bool removeModule(Module *M)
removeModule - Removes a Module from the list of modules, but does not free the module's memory.
virtual void * getPointerToFunction(Function *F)=0
getPointerToFunction - The different EE's represent function bodies in different ways.
sys::Mutex lock
lock - This lock protects the ExecutionEngine and MCJIT classes.
static ExecutionEngine *(* InterpCtor)(std::unique_ptr< Module > M, std::string *ErrorStr)
virtual void runStaticConstructorsDestructors(bool isDtors)
runStaticConstructorsDestructors - This method is used to execute all of the static constructors or d...
static ExecutionEngine *(* MCJITCtor)(std::unique_ptr< Module > M, std::string *ErrorStr, std::shared_ptr< MCJITMemoryManager > MM, std::shared_ptr< LegacyJITSymbolResolver > SR, std::unique_ptr< TargetMachine > TM)
void addGlobalMapping(const GlobalValue *GV, void *Addr)
addGlobalMapping - Tell the execution engine that the specified global is at the specified location.
SmallVector< std::unique_ptr< Module >, 1 > Modules
The list of Modules that we are JIT'ing from.
const GlobalValue * getGlobalValueAtAddress(void *Addr)
getGlobalValueAtAddress - Return the LLVM global value object that starts at the specified address.
ExecutionEngine(DataLayout DL)
void clearGlobalMappingsFromModule(Module *M)
clearGlobalMappingsFromModule - Clear all global mappings that came from a particular module,...
void * getPointerToGlobal(const GlobalValue *GV)
getPointerToGlobal - This returns the address of the specified global value.
int runFunctionAsMain(Function *Fn, const std::vector< std::string > &argv, const char *const *envp)
runFunctionAsMain - This is a helper function which wraps runFunction to handle the common task of st...
virtual void addObjectFile(std::unique_ptr< object::ObjectFile > O)
addObjectFile - Add an ObjectFile to the execution engine.
virtual void * getOrEmitGlobalVariable(const GlobalVariable *GV)
getOrEmitGlobalVariable - Return the address of the specified global variable, possibly emitting it t...
uint64_t getAddressToGlobalIfAvailable(StringRef S)
getAddressToGlobalIfAvailable - This returns the address of the specified global symbol.
void emitGlobalVariable(const GlobalVariable *GV)
virtual GlobalVariable * FindGlobalVariableNamed(StringRef Name, bool AllowInternal=false)
FindGlobalVariableNamed - Search all of the active modules to find the global variable that defines N...
virtual GenericValue runFunction(Function *F, ArrayRef< GenericValue > ArgValues)=0
runFunction - Execute the specified function with the specified arguments, and return the result.
void emitGlobals()
EmitGlobals - Emit all of the global variables to memory, storing their addresses into GlobalAddress.
void LoadValueFromMemory(GenericValue &Result, GenericValue *Ptr, Type *Ty)
FIXME: document.
uint64_t updateGlobalMapping(const GlobalValue *GV, void *Addr)
updateGlobalMapping - Replace an existing mapping for GV with a new address.
virtual char * getMemoryForGV(const GlobalVariable *GV)
getMemoryforGV - Allocate memory for a global variable.
virtual Function * FindFunctionNamed(StringRef FnName)
FindFunctionNamed - Search all of the active modules to find the function that defines FnName.
Class to represent function types.
Definition: DerivedTypes.h:103
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Definition: DerivedTypes.h:139
Type * getParamType(unsigned i) const
Parameter type accessors.
Definition: DerivedTypes.h:135
Type * getReturnType() const
Definition: DerivedTypes.h:124
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:176
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
Definition: Function.cpp:320
bool hasExternalLinkage() const
Definition: GlobalValue.h:506
bool isThreadLocal() const
If the value is "Thread Local", its value isn't shared by the threads.
Definition: GlobalValue.h:259
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:273
bool hasLocalLinkage() const
Definition: GlobalValue.h:523
bool hasExternalWeakLinkage() const
Definition: GlobalValue.h:524
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:652
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:290
bool hasAppendingLinkage() const
Definition: GlobalValue.h:520
Type * getValueType() const
Definition: GlobalValue.h:292
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
void dump() const
Debugging method that may be called through a debugger; just invokes print on stderr.
Definition: Record.cpp:347
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
void getNameWithPrefix(raw_ostream &OS, const GlobalValue *GV, bool CannotUsePrivateLabel) const
Print the appropriate prefix and the specified global variable's name.
Definition: Mangler.cpp:119
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.h:254
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:307
static PointerType * get(Type *ElementType, unsigned AddressSpace)
This constructs a pointer to an object of the specified type in a numbered address space.
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:2190
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:261
iterator end()
Definition: StringMap.h:205
iterator begin()
Definition: StringMap.h:204
iterator find(StringRef Key)
Definition: StringMap.h:218
void erase(iterator I)
Definition: StringMap.h:382
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
Definition: DataLayout.h:622
TypeSize getElementOffset(unsigned Idx) const
Definition: DataLayout.h:651
Class to represent struct types.
Definition: DerivedTypes.h:213
@ HasZeroInit
zeroinitializer is valid for this target extension type.
Definition: DerivedTypes.h:798
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:78
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
bool isX86_FP80Ty() const
Return true if this is x86 long double.
Definition: Type.h:160
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:255
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
Definition: Type.h:154
@ ScalableVectorTyID
Scalable SIMD vector type.
Definition: Type.h:77
@ FloatTyID
32-bit floating point type
Definition: Type.h:58
@ StructTyID
Structures.
Definition: Type.h:74
@ IntegerTyID
Arbitrary bit width integers.
Definition: Type.h:71
@ FixedVectorTyID
Fixed width SIMD vector type.
Definition: Type.h:76
@ DoubleTyID
64-bit floating point type
Definition: Type.h:59
@ X86_FP80TyID
80-bit floating point type (X87)
Definition: Type.h:60
@ PPC_FP128TyID
128-bit floating point type (two 64-bits, PowerPC)
Definition: Type.h:62
@ PointerTyID
Pointers.
Definition: Type.h:73
@ FP128TyID
128-bit floating point type (112-bit significand)
Definition: Type.h:61
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
bool isAggregateType() const
Return true if the type is an aggregate type.
Definition: Type.h:295
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
Definition: Type.h:157
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
bool isFloatingPointTy() const
Return true if this is one of the floating-point types.
Definition: Type.h:185
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:228
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:137
TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
bool isVoidTy() const
Return true if this is 'void'.
Definition: Type.h:140
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1724
Value * getOperand(unsigned i) const
Definition: User.h:169
unsigned getNumOperands() const
Definition: User.h:191
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
bool hasName() const
Definition: Value.h:261
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:672
static bool LoadLibraryPermanently(const char *Filename, std::string *ErrMsg=nullptr)
This function permanently loads the dynamic library at the given path.
static void * SearchForAddressOfSymbol(const char *symbolName)
This function will search through all previously loaded dynamic libraries for the symbol symbolName.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
APInt RoundFloatToAPInt(float Float, unsigned width)
Converts a float value into a APInt.
Definition: APInt.h:2232
APInt RoundDoubleToAPInt(double Double, unsigned width)
Converts the given double value into a APInt.
Definition: APInt.cpp:810
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:228
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:237
static const bool IsLittleEndianHost
Definition: SwapByteOrder.h:57
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:440
void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst, unsigned StoreBytes)
StoreIntToMemory - Fills the StoreBytes bytes of memory starting from Dst with the integer held in In...
Definition: APInt.cpp:3028
void * PointerTy
Definition: GenericValue.h:21
GenericValue PTOGV(void *P)
Definition: GenericValue.h:49
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:156
CodeGenOptLevel
Code generation optimization level.
Definition: CodeGen.h:54
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:155
constexpr unsigned BitWidth
Definition: BitmaskEnum.h:184
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1854
void * GVTOP(const GenericValue &GV)
Definition: GenericValue.h:50
@ Default
The result values are uniform if and only if all operands are uniform.
void LoadIntFromMemory(APInt &IntVal, const uint8_t *Src, unsigned LoadBytes)
LoadIntFromMemory - Loads the integer stored in the LoadBytes bytes starting from Src into IntVal,...
Definition: APInt.cpp:3054
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
static constexpr roundingMode rmNearestTiesToEven
Definition: APFloat.h:230
static constexpr roundingMode rmTowardZero
Definition: APFloat.h:234
static const fltSemantics & x87DoubleExtended() LLVM_READNONE
Definition: APFloat.cpp:263
PointerTy PointerVal
Definition: GenericValue.h:31
std::vector< GenericValue > AggregateVal
Definition: GenericValue.h:37