LLVM 19.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);
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 = PointerType::getUnqual(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 sentinel 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");
621 case Type::ArrayTyID: {
622 auto *ArrTy = cast<ArrayType>(C->getType());
623 Type *ElemTy = ArrTy->getElementType();
624 unsigned int elemNum = ArrTy->getNumElements();
625 Result.AggregateVal.resize(elemNum);
626 if (ElemTy->isIntegerTy())
627 for (unsigned int i = 0; i < elemNum; ++i)
628 Result.AggregateVal[i].IntVal =
629 APInt(ElemTy->getPrimitiveSizeInBits(), 0);
630 break;
631 }
633 // if the whole vector is 'undef' just reserve memory for the value.
634 auto *VTy = cast<FixedVectorType>(C->getType());
635 Type *ElemTy = VTy->getElementType();
636 unsigned int elemNum = VTy->getNumElements();
637 Result.AggregateVal.resize(elemNum);
638 if (ElemTy->isIntegerTy())
639 for (unsigned int i = 0; i < elemNum; ++i)
640 Result.AggregateVal[i].IntVal =
641 APInt(ElemTy->getPrimitiveSizeInBits(), 0);
642 break;
643 }
644 }
645 return Result;
646 }
647
648 // Otherwise, if the value is a ConstantExpr...
649 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
650 Constant *Op0 = CE->getOperand(0);
651 switch (CE->getOpcode()) {
652 case Instruction::GetElementPtr: {
653 // Compute the index
654 GenericValue Result = getConstantValue(Op0);
656 cast<GEPOperator>(CE)->accumulateConstantOffset(DL, Offset);
657
658 char* tmp = (char*) Result.PointerVal;
659 Result = PTOGV(tmp + Offset.getSExtValue());
660 return Result;
661 }
662 case Instruction::Trunc: {
664 uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
665 GV.IntVal = GV.IntVal.trunc(BitWidth);
666 return GV;
667 }
668 case Instruction::ZExt: {
670 uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
671 GV.IntVal = GV.IntVal.zext(BitWidth);
672 return GV;
673 }
674 case Instruction::SExt: {
676 uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
677 GV.IntVal = GV.IntVal.sext(BitWidth);
678 return GV;
679 }
680 case Instruction::FPTrunc: {
681 // FIXME long double
683 GV.FloatVal = float(GV.DoubleVal);
684 return GV;
685 }
686 case Instruction::FPExt:{
687 // FIXME long double
689 GV.DoubleVal = double(GV.FloatVal);
690 return GV;
691 }
692 case Instruction::UIToFP: {
694 if (CE->getType()->isFloatTy())
695 GV.FloatVal = float(GV.IntVal.roundToDouble());
696 else if (CE->getType()->isDoubleTy())
698 else if (CE->getType()->isX86_FP80Ty()) {
700 (void)apf.convertFromAPInt(GV.IntVal,
701 false,
703 GV.IntVal = apf.bitcastToAPInt();
704 }
705 return GV;
706 }
707 case Instruction::SIToFP: {
709 if (CE->getType()->isFloatTy())
710 GV.FloatVal = float(GV.IntVal.signedRoundToDouble());
711 else if (CE->getType()->isDoubleTy())
713 else if (CE->getType()->isX86_FP80Ty()) {
715 (void)apf.convertFromAPInt(GV.IntVal,
716 true,
718 GV.IntVal = apf.bitcastToAPInt();
719 }
720 return GV;
721 }
722 case Instruction::FPToUI: // double->APInt conversion handles sign
723 case Instruction::FPToSI: {
725 uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
726 if (Op0->getType()->isFloatTy())
728 else if (Op0->getType()->isDoubleTy())
730 else if (Op0->getType()->isX86_FP80Ty()) {
732 uint64_t v;
733 bool ignored;
735 CE->getOpcode()==Instruction::FPToSI,
737 GV.IntVal = v; // endian?
738 }
739 return GV;
740 }
741 case Instruction::PtrToInt: {
743 uint32_t PtrWidth = DL.getTypeSizeInBits(Op0->getType());
744 assert(PtrWidth <= 64 && "Bad pointer width");
745 GV.IntVal = APInt(PtrWidth, uintptr_t(GV.PointerVal));
746 uint32_t IntWidth = DL.getTypeSizeInBits(CE->getType());
747 GV.IntVal = GV.IntVal.zextOrTrunc(IntWidth);
748 return GV;
749 }
750 case Instruction::IntToPtr: {
752 uint32_t PtrWidth = DL.getTypeSizeInBits(CE->getType());
753 GV.IntVal = GV.IntVal.zextOrTrunc(PtrWidth);
754 assert(GV.IntVal.getBitWidth() <= 64 && "Bad pointer width");
755 GV.PointerVal = PointerTy(uintptr_t(GV.IntVal.getZExtValue()));
756 return GV;
757 }
758 case Instruction::BitCast: {
760 Type* DestTy = CE->getType();
761 switch (Op0->getType()->getTypeID()) {
762 default: llvm_unreachable("Invalid bitcast operand");
764 assert(DestTy->isFloatingPointTy() && "invalid bitcast");
765 if (DestTy->isFloatTy())
766 GV.FloatVal = GV.IntVal.bitsToFloat();
767 else if (DestTy->isDoubleTy())
768 GV.DoubleVal = GV.IntVal.bitsToDouble();
769 break;
770 case Type::FloatTyID:
771 assert(DestTy->isIntegerTy(32) && "Invalid bitcast");
773 break;
774 case Type::DoubleTyID:
775 assert(DestTy->isIntegerTy(64) && "Invalid bitcast");
777 break;
779 assert(DestTy->isPointerTy() && "Invalid bitcast");
780 break; // getConstantValue(Op0) above already converted it
781 }
782 return GV;
783 }
784 case Instruction::Add:
785 case Instruction::FAdd:
786 case Instruction::Sub:
787 case Instruction::FSub:
788 case Instruction::Mul:
789 case Instruction::FMul:
790 case Instruction::UDiv:
791 case Instruction::SDiv:
792 case Instruction::URem:
793 case Instruction::SRem:
794 case Instruction::And:
795 case Instruction::Or:
796 case Instruction::Xor: {
798 GenericValue RHS = getConstantValue(CE->getOperand(1));
799 GenericValue GV;
800 switch (CE->getOperand(0)->getType()->getTypeID()) {
801 default: llvm_unreachable("Bad add type!");
803 switch (CE->getOpcode()) {
804 default: llvm_unreachable("Invalid integer opcode");
805 case Instruction::Add: GV.IntVal = LHS.IntVal + RHS.IntVal; break;
806 case Instruction::Sub: GV.IntVal = LHS.IntVal - RHS.IntVal; break;
807 case Instruction::Mul: GV.IntVal = LHS.IntVal * RHS.IntVal; break;
808 case Instruction::UDiv:GV.IntVal = LHS.IntVal.udiv(RHS.IntVal); break;
809 case Instruction::SDiv:GV.IntVal = LHS.IntVal.sdiv(RHS.IntVal); break;
810 case Instruction::URem:GV.IntVal = LHS.IntVal.urem(RHS.IntVal); break;
811 case Instruction::SRem:GV.IntVal = LHS.IntVal.srem(RHS.IntVal); break;
812 case Instruction::And: GV.IntVal = LHS.IntVal & RHS.IntVal; break;
813 case Instruction::Or: GV.IntVal = LHS.IntVal | RHS.IntVal; break;
814 case Instruction::Xor: GV.IntVal = LHS.IntVal ^ RHS.IntVal; break;
815 }
816 break;
817 case Type::FloatTyID:
818 switch (CE->getOpcode()) {
819 default: llvm_unreachable("Invalid float opcode");
820 case Instruction::FAdd:
821 GV.FloatVal = LHS.FloatVal + RHS.FloatVal; break;
822 case Instruction::FSub:
823 GV.FloatVal = LHS.FloatVal - RHS.FloatVal; break;
824 case Instruction::FMul:
825 GV.FloatVal = LHS.FloatVal * RHS.FloatVal; break;
826 case Instruction::FDiv:
827 GV.FloatVal = LHS.FloatVal / RHS.FloatVal; break;
828 case Instruction::FRem:
829 GV.FloatVal = std::fmod(LHS.FloatVal,RHS.FloatVal); break;
830 }
831 break;
832 case Type::DoubleTyID:
833 switch (CE->getOpcode()) {
834 default: llvm_unreachable("Invalid double opcode");
835 case Instruction::FAdd:
836 GV.DoubleVal = LHS.DoubleVal + RHS.DoubleVal; break;
837 case Instruction::FSub:
838 GV.DoubleVal = LHS.DoubleVal - RHS.DoubleVal; break;
839 case Instruction::FMul:
840 GV.DoubleVal = LHS.DoubleVal * RHS.DoubleVal; break;
841 case Instruction::FDiv:
842 GV.DoubleVal = LHS.DoubleVal / RHS.DoubleVal; break;
843 case Instruction::FRem:
844 GV.DoubleVal = std::fmod(LHS.DoubleVal,RHS.DoubleVal); break;
845 }
846 break;
849 case Type::FP128TyID: {
850 const fltSemantics &Sem = CE->getOperand(0)->getType()->getFltSemantics();
851 APFloat apfLHS = APFloat(Sem, LHS.IntVal);
852 switch (CE->getOpcode()) {
853 default: llvm_unreachable("Invalid long double opcode");
854 case Instruction::FAdd:
855 apfLHS.add(APFloat(Sem, RHS.IntVal), APFloat::rmNearestTiesToEven);
856 GV.IntVal = apfLHS.bitcastToAPInt();
857 break;
858 case Instruction::FSub:
859 apfLHS.subtract(APFloat(Sem, RHS.IntVal),
861 GV.IntVal = apfLHS.bitcastToAPInt();
862 break;
863 case Instruction::FMul:
864 apfLHS.multiply(APFloat(Sem, RHS.IntVal),
866 GV.IntVal = apfLHS.bitcastToAPInt();
867 break;
868 case Instruction::FDiv:
869 apfLHS.divide(APFloat(Sem, RHS.IntVal),
871 GV.IntVal = apfLHS.bitcastToAPInt();
872 break;
873 case Instruction::FRem:
874 apfLHS.mod(APFloat(Sem, RHS.IntVal));
875 GV.IntVal = apfLHS.bitcastToAPInt();
876 break;
877 }
878 }
879 break;
880 }
881 return GV;
882 }
883 default:
884 break;
885 }
886
889 OS << "ConstantExpr not handled: " << *CE;
890 report_fatal_error(OS.str());
891 }
892
893 if (auto *TETy = dyn_cast<TargetExtType>(C->getType())) {
894 assert(TETy->hasProperty(TargetExtType::HasZeroInit) && C->isNullValue() &&
895 "TargetExtType only supports null constant value");
896 C = Constant::getNullValue(TETy->getLayoutType());
897 }
898
899 // Otherwise, we have a simple constant.
900 GenericValue Result;
901 switch (C->getType()->getTypeID()) {
902 case Type::FloatTyID:
903 Result.FloatVal = cast<ConstantFP>(C)->getValueAPF().convertToFloat();
904 break;
905 case Type::DoubleTyID:
906 Result.DoubleVal = cast<ConstantFP>(C)->getValueAPF().convertToDouble();
907 break;
909 case Type::FP128TyID:
911 Result.IntVal = cast <ConstantFP>(C)->getValueAPF().bitcastToAPInt();
912 break;
914 Result.IntVal = cast<ConstantInt>(C)->getValue();
915 break;
917 while (auto *A = dyn_cast<GlobalAlias>(C)) {
918 C = A->getAliasee();
919 }
920 if (isa<ConstantPointerNull>(C))
921 Result.PointerVal = nullptr;
922 else if (const Function *F = dyn_cast<Function>(C))
923 Result = PTOGV(getPointerToFunctionOrStub(const_cast<Function*>(F)));
924 else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(C))
925 Result = PTOGV(getOrEmitGlobalVariable(const_cast<GlobalVariable*>(GV)));
926 else
927 llvm_unreachable("Unknown constant pointer type!");
928 break;
931 "Scalable vector support not yet implemented in ExecutionEngine");
933 unsigned elemNum;
934 Type* ElemTy;
935 const ConstantDataVector *CDV = dyn_cast<ConstantDataVector>(C);
936 const ConstantVector *CV = dyn_cast<ConstantVector>(C);
937 const ConstantAggregateZero *CAZ = dyn_cast<ConstantAggregateZero>(C);
938
939 if (CDV) {
940 elemNum = CDV->getNumElements();
941 ElemTy = CDV->getElementType();
942 } else if (CV || CAZ) {
943 auto *VTy = cast<FixedVectorType>(C->getType());
944 elemNum = VTy->getNumElements();
945 ElemTy = VTy->getElementType();
946 } else {
947 llvm_unreachable("Unknown constant vector type!");
948 }
949
950 Result.AggregateVal.resize(elemNum);
951 // Check if vector holds floats.
952 if(ElemTy->isFloatTy()) {
953 if (CAZ) {
954 GenericValue floatZero;
955 floatZero.FloatVal = 0.f;
956 std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),
957 floatZero);
958 break;
959 }
960 if(CV) {
961 for (unsigned i = 0; i < elemNum; ++i)
962 if (!isa<UndefValue>(CV->getOperand(i)))
963 Result.AggregateVal[i].FloatVal = cast<ConstantFP>(
964 CV->getOperand(i))->getValueAPF().convertToFloat();
965 break;
966 }
967 if(CDV)
968 for (unsigned i = 0; i < elemNum; ++i)
969 Result.AggregateVal[i].FloatVal = CDV->getElementAsFloat(i);
970
971 break;
972 }
973 // Check if vector holds doubles.
974 if (ElemTy->isDoubleTy()) {
975 if (CAZ) {
976 GenericValue doubleZero;
977 doubleZero.DoubleVal = 0.0;
978 std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),
979 doubleZero);
980 break;
981 }
982 if(CV) {
983 for (unsigned i = 0; i < elemNum; ++i)
984 if (!isa<UndefValue>(CV->getOperand(i)))
985 Result.AggregateVal[i].DoubleVal = cast<ConstantFP>(
986 CV->getOperand(i))->getValueAPF().convertToDouble();
987 break;
988 }
989 if(CDV)
990 for (unsigned i = 0; i < elemNum; ++i)
991 Result.AggregateVal[i].DoubleVal = CDV->getElementAsDouble(i);
992
993 break;
994 }
995 // Check if vector holds integers.
996 if (ElemTy->isIntegerTy()) {
997 if (CAZ) {
998 GenericValue intZero;
999 intZero.IntVal = APInt(ElemTy->getScalarSizeInBits(), 0ull);
1000 std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),
1001 intZero);
1002 break;
1003 }
1004 if(CV) {
1005 for (unsigned i = 0; i < elemNum; ++i)
1006 if (!isa<UndefValue>(CV->getOperand(i)))
1007 Result.AggregateVal[i].IntVal = cast<ConstantInt>(
1008 CV->getOperand(i))->getValue();
1009 else {
1010 Result.AggregateVal[i].IntVal =
1012 }
1013 break;
1014 }
1015 if(CDV)
1016 for (unsigned i = 0; i < elemNum; ++i)
1017 Result.AggregateVal[i].IntVal = APInt(
1019 CDV->getElementAsInteger(i));
1020
1021 break;
1022 }
1023 llvm_unreachable("Unknown constant pointer type!");
1024 } break;
1025
1026 default:
1027 SmallString<256> Msg;
1029 OS << "ERROR: Constant unimplemented for type: " << *C->getType();
1030 report_fatal_error(OS.str());
1031 }
1032
1033 return Result;
1034}
1035
1037 GenericValue *Ptr, Type *Ty) {
1038 // It is safe to treat TargetExtType as its layout type since the underlying
1039 // bits are only copied and are not inspected.
1040 if (auto *TETy = dyn_cast<TargetExtType>(Ty))
1041 Ty = TETy->getLayoutType();
1042
1043 const unsigned StoreBytes = getDataLayout().getTypeStoreSize(Ty);
1044
1045 switch (Ty->getTypeID()) {
1046 default:
1047 dbgs() << "Cannot store value of type " << *Ty << "!\n";
1048 break;
1049 case Type::IntegerTyID:
1050 StoreIntToMemory(Val.IntVal, (uint8_t*)Ptr, StoreBytes);
1051 break;
1052 case Type::FloatTyID:
1053 *((float*)Ptr) = Val.FloatVal;
1054 break;
1055 case Type::DoubleTyID:
1056 *((double*)Ptr) = Val.DoubleVal;
1057 break;
1058 case Type::X86_FP80TyID:
1059 memcpy(Ptr, Val.IntVal.getRawData(), 10);
1060 break;
1061 case Type::PointerTyID:
1062 // Ensure 64 bit target pointers are fully initialized on 32 bit hosts.
1063 if (StoreBytes != sizeof(PointerTy))
1064 memset(&(Ptr->PointerVal), 0, StoreBytes);
1065
1066 *((PointerTy*)Ptr) = Val.PointerVal;
1067 break;
1070 for (unsigned i = 0; i < Val.AggregateVal.size(); ++i) {
1071 if (cast<VectorType>(Ty)->getElementType()->isDoubleTy())
1072 *(((double*)Ptr)+i) = Val.AggregateVal[i].DoubleVal;
1073 if (cast<VectorType>(Ty)->getElementType()->isFloatTy())
1074 *(((float*)Ptr)+i) = Val.AggregateVal[i].FloatVal;
1075 if (cast<VectorType>(Ty)->getElementType()->isIntegerTy()) {
1076 unsigned numOfBytes =(Val.AggregateVal[i].IntVal.getBitWidth()+7)/8;
1077 StoreIntToMemory(Val.AggregateVal[i].IntVal,
1078 (uint8_t*)Ptr + numOfBytes*i, numOfBytes);
1079 }
1080 }
1081 break;
1082 }
1083
1084 if (sys::IsLittleEndianHost != getDataLayout().isLittleEndian())
1085 // Host and target are different endian - reverse the stored bytes.
1086 std::reverse((uint8_t*)Ptr, StoreBytes + (uint8_t*)Ptr);
1087}
1088
1089/// FIXME: document
1090///
1093 Type *Ty) {
1094 if (auto *TETy = dyn_cast<TargetExtType>(Ty))
1095 Ty = TETy->getLayoutType();
1096
1097 const unsigned LoadBytes = getDataLayout().getTypeStoreSize(Ty);
1098
1099 switch (Ty->getTypeID()) {
1100 case Type::IntegerTyID:
1101 // An APInt with all words initially zero.
1102 Result.IntVal = APInt(cast<IntegerType>(Ty)->getBitWidth(), 0);
1103 LoadIntFromMemory(Result.IntVal, (uint8_t*)Ptr, LoadBytes);
1104 break;
1105 case Type::FloatTyID:
1106 Result.FloatVal = *((float*)Ptr);
1107 break;
1108 case Type::DoubleTyID:
1109 Result.DoubleVal = *((double*)Ptr);
1110 break;
1111 case Type::PointerTyID:
1112 Result.PointerVal = *((PointerTy*)Ptr);
1113 break;
1114 case Type::X86_FP80TyID: {
1115 // This is endian dependent, but it will only work on x86 anyway.
1116 // FIXME: Will not trap if loading a signaling NaN.
1117 uint64_t y[2];
1118 memcpy(y, Ptr, 10);
1119 Result.IntVal = APInt(80, y);
1120 break;
1121 }
1124 "Scalable vector support not yet implemented in ExecutionEngine");
1125 case Type::FixedVectorTyID: {
1126 auto *VT = cast<FixedVectorType>(Ty);
1127 Type *ElemT = VT->getElementType();
1128 const unsigned numElems = VT->getNumElements();
1129 if (ElemT->isFloatTy()) {
1130 Result.AggregateVal.resize(numElems);
1131 for (unsigned i = 0; i < numElems; ++i)
1132 Result.AggregateVal[i].FloatVal = *((float*)Ptr+i);
1133 }
1134 if (ElemT->isDoubleTy()) {
1135 Result.AggregateVal.resize(numElems);
1136 for (unsigned i = 0; i < numElems; ++i)
1137 Result.AggregateVal[i].DoubleVal = *((double*)Ptr+i);
1138 }
1139 if (ElemT->isIntegerTy()) {
1140 GenericValue intZero;
1141 const unsigned elemBitWidth = cast<IntegerType>(ElemT)->getBitWidth();
1142 intZero.IntVal = APInt(elemBitWidth, 0);
1143 Result.AggregateVal.resize(numElems, intZero);
1144 for (unsigned i = 0; i < numElems; ++i)
1145 LoadIntFromMemory(Result.AggregateVal[i].IntVal,
1146 (uint8_t*)Ptr+((elemBitWidth+7)/8)*i, (elemBitWidth+7)/8);
1147 }
1148 break;
1149 }
1150 default:
1151 SmallString<256> Msg;
1153 OS << "Cannot load value of type " << *Ty << "!";
1154 report_fatal_error(OS.str());
1155 }
1156}
1157
1159 LLVM_DEBUG(dbgs() << "JIT: Initializing " << Addr << " ");
1160 LLVM_DEBUG(Init->dump());
1161 if (isa<UndefValue>(Init))
1162 return;
1163
1164 if (const ConstantVector *CP = dyn_cast<ConstantVector>(Init)) {
1165 unsigned ElementSize =
1166 getDataLayout().getTypeAllocSize(CP->getType()->getElementType());
1167 for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i)
1168 InitializeMemory(CP->getOperand(i), (char*)Addr+i*ElementSize);
1169 return;
1170 }
1171
1172 if (isa<ConstantAggregateZero>(Init)) {
1173 memset(Addr, 0, (size_t)getDataLayout().getTypeAllocSize(Init->getType()));
1174 return;
1175 }
1176
1177 if (const ConstantArray *CPA = dyn_cast<ConstantArray>(Init)) {
1178 unsigned ElementSize =
1179 getDataLayout().getTypeAllocSize(CPA->getType()->getElementType());
1180 for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i)
1181 InitializeMemory(CPA->getOperand(i), (char*)Addr+i*ElementSize);
1182 return;
1183 }
1184
1185 if (const ConstantStruct *CPS = dyn_cast<ConstantStruct>(Init)) {
1186 const StructLayout *SL =
1187 getDataLayout().getStructLayout(cast<StructType>(CPS->getType()));
1188 for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i)
1189 InitializeMemory(CPS->getOperand(i), (char*)Addr+SL->getElementOffset(i));
1190 return;
1191 }
1192
1193 if (const ConstantDataSequential *CDS =
1194 dyn_cast<ConstantDataSequential>(Init)) {
1195 // CDS is already laid out in host memory order.
1196 StringRef Data = CDS->getRawDataValues();
1197 memcpy(Addr, Data.data(), Data.size());
1198 return;
1199 }
1200
1201 if (Init->getType()->isFirstClassType()) {
1203 StoreValueToMemory(Val, (GenericValue*)Addr, Init->getType());
1204 return;
1205 }
1206
1207 LLVM_DEBUG(dbgs() << "Bad Type: " << *Init->getType() << "\n");
1208 llvm_unreachable("Unknown constant type to initialize memory with!");
1209}
1210
1211/// EmitGlobals - Emit all of the global variables to memory, storing their
1212/// addresses into GlobalAddress. This must make sure to copy the contents of
1213/// their initializers into the memory.
1215 // Loop over all of the global variables in the program, allocating the memory
1216 // to hold them. If there is more than one module, do a prepass over globals
1217 // to figure out how the different modules should link together.
1218 std::map<std::pair<std::string, Type*>,
1219 const GlobalValue*> LinkedGlobalsMap;
1220
1221 if (Modules.size() != 1) {
1222 for (unsigned m = 0, e = Modules.size(); m != e; ++m) {
1223 Module &M = *Modules[m];
1224 for (const auto &GV : M.globals()) {
1225 if (GV.hasLocalLinkage() || GV.isDeclaration() ||
1226 GV.hasAppendingLinkage() || !GV.hasName())
1227 continue;// Ignore external globals and globals with internal linkage.
1228
1229 const GlobalValue *&GVEntry = LinkedGlobalsMap[std::make_pair(
1230 std::string(GV.getName()), GV.getType())];
1231
1232 // If this is the first time we've seen this global, it is the canonical
1233 // version.
1234 if (!GVEntry) {
1235 GVEntry = &GV;
1236 continue;
1237 }
1238
1239 // If the existing global is strong, never replace it.
1240 if (GVEntry->hasExternalLinkage())
1241 continue;
1242
1243 // Otherwise, we know it's linkonce/weak, replace it if this is a strong
1244 // symbol. FIXME is this right for common?
1245 if (GV.hasExternalLinkage() || GVEntry->hasExternalWeakLinkage())
1246 GVEntry = &GV;
1247 }
1248 }
1249 }
1250
1251 std::vector<const GlobalValue*> NonCanonicalGlobals;
1252 for (unsigned m = 0, e = Modules.size(); m != e; ++m) {
1253 Module &M = *Modules[m];
1254 for (const auto &GV : M.globals()) {
1255 // In the multi-module case, see what this global maps to.
1256 if (!LinkedGlobalsMap.empty()) {
1257 if (const GlobalValue *GVEntry = LinkedGlobalsMap[std::make_pair(
1258 std::string(GV.getName()), GV.getType())]) {
1259 // If something else is the canonical global, ignore this one.
1260 if (GVEntry != &GV) {
1261 NonCanonicalGlobals.push_back(&GV);
1262 continue;
1263 }
1264 }
1265 }
1266
1267 if (!GV.isDeclaration()) {
1269 } else {
1270 // External variable reference. Try to use the dynamic loader to
1271 // get a pointer to it.
1273 std::string(GV.getName())))
1274 addGlobalMapping(&GV, SymAddr);
1275 else {
1276 report_fatal_error("Could not resolve external global address: "
1277 +GV.getName());
1278 }
1279 }
1280 }
1281
1282 // If there are multiple modules, map the non-canonical globals to their
1283 // canonical location.
1284 if (!NonCanonicalGlobals.empty()) {
1285 for (const GlobalValue *GV : NonCanonicalGlobals) {
1286 const GlobalValue *CGV = LinkedGlobalsMap[std::make_pair(
1287 std::string(GV->getName()), GV->getType())];
1289 assert(Ptr && "Canonical global wasn't codegen'd!");
1290 addGlobalMapping(GV, Ptr);
1291 }
1292 }
1293
1294 // Now that all of the globals are set up in memory, loop through them all
1295 // and initialize their contents.
1296 for (const auto &GV : M.globals()) {
1297 if (!GV.isDeclaration()) {
1298 if (!LinkedGlobalsMap.empty()) {
1299 if (const GlobalValue *GVEntry = LinkedGlobalsMap[std::make_pair(
1300 std::string(GV.getName()), GV.getType())])
1301 if (GVEntry != &GV) // Not the canonical variable.
1302 continue;
1303 }
1304 emitGlobalVariable(&GV);
1305 }
1306 }
1307 }
1308}
1309
1310// EmitGlobalVariable - This method emits the specified global variable to the
1311// address specified in GlobalAddresses, or allocates new memory if it's not
1312// already in the map.
1314 void *GA = getPointerToGlobalIfAvailable(GV);
1315
1316 if (!GA) {
1317 // If it's not already specified, allocate memory for the global.
1318 GA = getMemoryForGV(GV);
1319
1320 // If we failed to allocate memory for this global, return.
1321 if (!GA) return;
1322
1323 addGlobalMapping(GV, GA);
1324 }
1325
1326 // Don't initialize if it's thread local, let the client do it.
1327 if (!GV->isThreadLocal())
1329
1330 Type *ElTy = GV->getValueType();
1331 size_t GVSize = (size_t)getDataLayout().getTypeAllocSize(ElTy);
1332 NumInitBytes += (unsigned)GVSize;
1333 ++NumGlobals;
1334}
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
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:1069
opStatus subtract(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:1051
opStatus add(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:1042
opStatus convertFromAPInt(const APInt &Input, bool IsSigned, roundingMode RM)
Definition: APFloat.h:1193
opStatus multiply(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:1060
APInt bitcastToAPInt() const
Definition: APFloat.h:1210
opStatus convertToInteger(MutableArrayRef< integerPart > Input, unsigned int Width, bool IsSigned, roundingMode RM, bool *IsExact) const
Definition: APFloat.h:1185
opStatus mod(const APFloat &RHS)
Definition: APFloat.h:1087
static APFloat getZero(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative Zero.
Definition: APFloat.h:957
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:1498
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:1701
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1446
double signedRoundToDouble() const
Converts this signed APInt to a double value.
Definition: APInt.h:1671
float bitsToFloat() const
Converts APInt bits to a float.
Definition: APInt.h:1685
static APInt doubleToBits(double V)
Converts a double to APInt bits.
Definition: APInt.h:1693
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:1678
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:351
ConstantArray - Constant Array Declarations.
Definition: Constants.h:424
ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...
Definition: Constants.h:584
double getElementAsDouble(unsigned i) const
If this is an sequential container of doubles, return the specified element as a double.
Definition: Constants.cpp:3084
float getElementAsFloat(unsigned i) const
If this is an sequential container of floats, return the specified element as a float.
Definition: Constants.cpp:3078
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:3005
unsigned getNumElements() const
Return the number of elements in the array or vector.
Definition: Constants.cpp:2748
Type * getElementType() const
Return the element type of the array/vector.
Definition: Constants.cpp:2722
A vector constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
Definition: Constants.h:767
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:1018
Constant Vector Declarations.
Definition: Constants.h:508
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:370
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:720
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:750
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:142
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:202
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
Definition: Function.cpp:356
bool hasExternalLinkage() const
Definition: GlobalValue.h:510
bool isThreadLocal() const
If the value is "Thread Local", its value isn't shared by the threads.
Definition: GlobalValue.h:262
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:286
bool hasLocalLinkage() const
Definition: GlobalValue.h:527
bool hasExternalWeakLinkage() const
Definition: GlobalValue.h:528
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:655
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:293
bool hasAppendingLinkage() const
Definition: GlobalValue.h:524
Type * getValueType() const
Definition: GlobalValue.h:295
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:120
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:293
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.
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the default address space (address sp...
Definition: DerivedTypes.h:662
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:2213
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
iterator end()
Definition: StringMap.h:220
iterator begin()
Definition: StringMap.h:219
iterator find(StringRef Key)
Definition: StringMap.h:233
void erase(iterator I)
Definition: StringMap.h:416
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:216
@ HasZeroInit
zeroinitializer is valid for this target extension type.
Definition: DerivedTypes.h:769
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:76
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
@ ArrayTyID
Arrays.
Definition: Type.h:75
@ 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
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:1808
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:690
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:2276
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:227
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:236
static const bool IsLittleEndianHost
Definition: SwapByteOrder.h:29
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
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:3020
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:159
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:191
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:1849
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:3046
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