ExecutionEngine.cpp Source File (original) (raw)

39#include

40#include

41#include

42using namespace llvm;

44#define DEBUG_TYPE "jit"

46 STATISTIC(NumInitBytes, "Number of bytes of global vars initialized");

47 STATISTIC(NumGlobals , "Number of global vars initialized");

50 std::unique_ptr M, std::string *ErrorStr,

51 std::shared_ptr MemMgr,

52 std::shared_ptr Resolver,

53 std::unique_ptr TM) = nullptr;

55ExecutionEngine *(*ExecutionEngine::InterpCtor)(std::unique_ptr M,

56 std::string *ErrorStr) =nullptr;

58void JITEventListener::anchor() {}

60void ObjectCache::anchor() {}

62void ExecutionEngine::Init(std::unique_ptr M) {

63 CompilingLazily = false;

64 GVCompilationDisabled = false;

65 SymbolSearchingDisabled = false;

69#ifndef NDEBUG

70 VerifyModules = true;

71#else

72 VerifyModules = false;

73#endif

75 assert(M && "Module is null?");

76 Modules.push_back(std::move(M));

77}

80 : DL(M->getDataLayout()), LazyFunctionCreator(nullptr) {

81 Init(std::move(M));

82}

85 : DL(std::move(DL)), LazyFunctionCreator(nullptr) {

86 Init(std::move(M));

87}

91}

93namespace {

96class GVMemoryBlock final : public CallbackVH {

100public:

101

102

106 void *RawMemory = ::operator new(

108 new(RawMemory) GVMemoryBlock(GV);

109 return static_cast<char*>(RawMemory) + sizeof(GVMemoryBlock);

110 }

111

112 void deleted() override {

113

114

115

116 this->~GVMemoryBlock();

117 ::operator delete(this);

118 }

119};

120}

121

123 return GVMemoryBlock::Create(GV, getDataLayout());

124}

125

127 llvm_unreachable("ExecutionEngine subclass doesn't implement addObjectFile.");

128}

129

130void

132 llvm_unreachable("ExecutionEngine subclass doesn't implement addObjectFile.");

133}

134

136 llvm_unreachable("ExecutionEngine subclass doesn't implement addArchive.");

137}

138

141 Module *Found = I->get();

142 if (Found == M) {

143 I->release();

146 return true;

147 }

148 }

149 return false;

150}

151

153 for (const auto &M : Modules) {

154 Function *F = M->getFunction(FnName);

155 if (F && ->isDeclaration())

156 return F;

157 }

158 return nullptr;

159}

160

162 for (const auto &M : Modules) {

165 return GV;

166 }

167 return nullptr;

168}

169

173

174

175

176 if (I == GlobalAddressMap.end())

177 OldVal = 0;

178 else {

179 GlobalAddressReverseMap.erase(I->second);

180 OldVal = I->second;

181 GlobalAddressMap.erase(I);

182 }

183

184 return OldVal;

185}

186

188 assert(GV->hasName() && "Global must have name.");

189

190 std::lock_guardsys::Mutex locked(lock);

192

197

199 return std::string(FullName);

200}

201

203 std::lock_guardsys::Mutex locked(lock);

205}

206

208 std::lock_guardsys::Mutex locked(lock);

209

210 assert( Name .empty() && "Empty GlobalMapping symbol name!");

211

214 assert((!CurVal || Addr ) && "GlobalMapping already established!");

215 CurVal = Addr;

216

217

220 assert((!V.empty() || Name .empty()) &&

221 "GlobalMapping already established!");

222 V = std::string(Name);

223 }

224}

225

227 std::lock_guardsys::Mutex locked(lock);

228

231}

232

234 std::lock_guardsys::Mutex locked(lock);

235

238}

239

241 void *Addr) {

242 std::lock_guardsys::Mutex locked(lock);

244}

245

247 std::lock_guardsys::Mutex locked(lock);

248

251

252

255

258

261 CurVal = Addr;

262

263

266 assert((!V.empty() || Name .empty()) &&

267 "GlobalMapping already established!");

268 V = std::string(Name);

269 }

270 return OldVal;

271}

272

274 std::lock_guardsys::Mutex locked(lock);

281}

282

283

285 std::lock_guardsys::Mutex locked(lock);

288 return nullptr;

289}

290

292 std::lock_guardsys::Mutex locked(lock);

294}

295

297 std::lock_guardsys::Mutex locked(lock);

298

299

307 std::make_pair(Addr, std::string(Name)));

308 }

309 }

310

311 std::map<uint64_t, std::string>::iterator I =

313

316 for (const auto &M : Modules)

318 return GV;

319 }

320 return nullptr;

321}

322

323namespace {

324class ArgvArray {

325 std::unique_ptr<char[]> Array;

326 std::vector<std::unique_ptr<char[]>> Values;

327public:

328

329

331 const std::vectorstd::string &InputArgv);

332};

333}

335 const std::vectorstd::string &InputArgv) {

336 Values.clear();

337 Values.reserve(InputArgv.size());

339 Array = std::make_unique<char[]>((InputArgv.size()+1)*PtrSize);

340

343

344 for (unsigned i = 0; i != InputArgv.size(); ++i) {

345 unsigned Size = InputArgv[i].size()+1;

346 auto Dest = std::make_unique<char[]>(Size);

347 LLVM_DEBUG(dbgs() << "JIT: ARGV[" << i << "] = " << (void *)Dest.get()

348 << "\n");

349

350 std::copy(InputArgv[i].begin(), InputArgv[i].end(), Dest.get());

351 Dest[Size-1] = 0;

352

353

355 (GenericValue*)(&Array[i*PtrSize]), SBytePtr);

356 Values.push_back(std::move(Dest));

357 }

358

359

361 (GenericValue*)(&Array[InputArgv.size()*PtrSize]),

362 SBytePtr);

363 return Array.get();

364}

365

367 bool isDtors) {

368 StringRef Name(isDtors ? "llvm.global_dtors" : "llvm.global_ctors");

370

371

372

373

374

376

377

378

380 if (!InitList)

381 return;

382 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) {

384 if (!CS) continue;

385

387 if (FP->isNullValue())

388 continue;

389

390

392 if (CE->isCast())

393 FP = CE->getOperand(0);

394

395

396 if (Function *F = dyn_cast(FP))

398

399

400

401

402 }

403}

404

406

407 for (std::unique_ptr &M : Modules)

409}

410

411#ifndef NDEBUG

412

415 for (unsigned i = 0; i < PtrSize; ++i)

416 if (*(i + (uint8_t*)Loc))

417 return false;

418 return true;

419}

420#endif

421

423 const std::vectorstd::string &argv,

424 const char * const * envp) {

425 std::vector GVArgs;

428

429

433

434

435 if (NumArgs > 3)

436 report_fatal_error("Invalid number of arguments of main() supplied");

437 if (NumArgs >= 3 && FTy->getParamType(2) != PPInt8Ty)

438 report_fatal_error("Invalid type for third argument of main() supplied");

439 if (NumArgs >= 2 && FTy->getParamType(1) != PPInt8Ty)

440 report_fatal_error("Invalid type for second argument of main() supplied");

442 report_fatal_error("Invalid type for first argument of main() supplied");

446

447 ArgvArray CArgv;

448 ArgvArray CEnv;

449 if (NumArgs) {

450 GVArgs.push_back(GVArgc);

451 if (NumArgs > 1) {

452

453 GVArgs.push_back(PTOGV(CArgv.reset(Fn->getContext(), this, argv)));

455 "argv[0] was null after CreateArgv");

456 if (NumArgs > 2) {

457 std::vectorstd::string EnvVars;

458 for (unsigned i = 0; envp[i]; ++i)

459 EnvVars.emplace_back(envp[i]);

460

461 GVArgs.push_back(PTOGV(CEnv.reset(Fn->getContext(), this, EnvVars)));

462 }

463 }

464 }

465

467}

468

470

472 : M(std::move(M)), WhichEngine(EngineKind::Either), ErrorStr(nullptr),

474

475

476#ifndef NDEBUG

477 VerifyModules = true;

478#else

479 VerifyModules = false;

480#endif

481}

482

484

486 std::unique_ptr mcjmm) {

487 auto SharedMM = std::shared_ptr(std::move(mcjmm));

488 MemMgr = SharedMM;

490 return *this;

491}

492

495 MemMgr = std::shared_ptr(std::move(MM));

496 return *this;

497}

498

501 Resolver = std::shared_ptr(std::move(SR));

502 return *this;

503}

504

506 std::unique_ptr TheTM(TM);

507

508

509

511 return nullptr;

512

513

514

515

516 if (MemMgr) {

519 else {

520 if (ErrorStr)

521 *ErrorStr = "Cannot create an interpreter with a memory manager.";

522 return nullptr;

523 }

524 }

525

526

527

529 if (!TM->getTarget().hasJIT()) {

530 errs() << "WARNING: This target JIT is not designed for the host"

531 << " you are running. If bad things happen, please choose"

532 << " a different -march switch.\n";

533 }

534

538 std::move(Resolver), std::move(TheTM));

539

540 if (EE) {

542 return EE;

543 }

544 }

545

546

547

551 if (ErrorStr)

552 *ErrorStr = "Interpreter has not been linked in.";

553 return nullptr;

554 }

555

557 if (ErrorStr)

558 *ErrorStr = "JIT has not been linked in.";

559 }

560

561 return nullptr;

562}

563

567

568 std::lock_guardsys::Mutex locked(lock);

570 return P;

571

572

574 const_cast<GlobalVariable *>(dyn_cast(GV)))

576 else

577 llvm_unreachable("Global hasn't had an address allocated yet!");

578

580}

581

582

583

585

586 if (isa(C)) {

588 switch (C->getType()->getTypeID()) {

589 default:

590 break;

595

596

597 Result.IntVal = APInt(C->getType()->getPrimitiveSizeInBits(), 0);

598 break;

600

601 if(StructType *STy = dyn_cast(C->getType())) {

602 unsigned int elemNum = STy->getNumElements();

603 Result.AggregateVal.resize(elemNum);

604 for (unsigned int i = 0; i < elemNum; ++i) {

605 Type *ElemTy = STy->getElementType(i);

607 Result.AggregateVal[i].IntVal =

612 }

613 }

614 }

615 }

616 break;

619 "Scalable vector support not yet implemented in ExecutionEngine");

621 auto *ArrTy = cast(C->getType());

622 Type *ElemTy = ArrTy->getElementType();

623 unsigned int elemNum = ArrTy->getNumElements();

624 Result.AggregateVal.resize(elemNum);

626 for (unsigned int i = 0; i < elemNum; ++i)

627 Result.AggregateVal[i].IntVal =

629 break;

630 }

632

633 auto *VTy = cast(C->getType());

634 Type *ElemTy = VTy->getElementType();

635 unsigned int elemNum = VTy->getNumElements();

636 Result.AggregateVal.resize(elemNum);

638 for (unsigned int i = 0; i < elemNum; ++i)

639 Result.AggregateVal[i].IntVal =

641 break;

642 }

643 }

644 return Result;

645 }

646

647

648 if (const ConstantExpr *CE = dyn_cast(C)) {

649 Constant *Op0 = CE->getOperand(0);

650 switch (CE->getOpcode()) {

651 case Instruction::GetElementPtr: {

652

655 cast(CE)->accumulateConstantOffset(DL, Offset);

656

657 char* tmp = (char*) Result.PointerVal;

658 Result = PTOGV(tmp + Offset.getSExtValue());

659 return Result;

660 }

661 case Instruction::Trunc: {

663 uint32_t BitWidth = cast(CE->getType())->getBitWidth();

665 return GV;

666 }

667 case Instruction::ZExt: {

669 uint32_t BitWidth = cast(CE->getType())->getBitWidth();

671 return GV;

672 }

673 case Instruction::SExt: {

675 uint32_t BitWidth = cast(CE->getType())->getBitWidth();

677 return GV;

678 }

679 case Instruction::FPTrunc: {

680

683 return GV;

684 }

685 case Instruction::FPExt:{

686

689 return GV;

690 }

691 case Instruction::UIToFP: {

693 if (CE->getType()->isFloatTy())

695 else if (CE->getType()->isDoubleTy())

697 else if (CE->getType()->isX86_FP80Ty()) {

700 false,

703 }

704 return GV;

705 }

706 case Instruction::SIToFP: {

708 if (CE->getType()->isFloatTy())

710 else if (CE->getType()->isDoubleTy())

712 else if (CE->getType()->isX86_FP80Ty()) {

715 true,

718 }

719 return GV;

720 }

721 case Instruction::FPToUI:

722 case Instruction::FPToSI: {

724 uint32_t BitWidth = cast(CE->getType())->getBitWidth();

734 CE->getOpcode()==Instruction::FPToSI,

736 GV.IntVal = v;

737 }

738 return GV;

739 }

740 case Instruction::PtrToInt: {

743 assert(PtrWidth <= 64 && "Bad pointer width");

747 return GV;

748 }

749 case Instruction::IntToPtr: {

755 return GV;

756 }

757 case Instruction::BitCast: {

759 Type* DestTy = CE->getType();

768 break;

772 break;

776 break;

779 break;

780 }

781 return GV;

782 }

783 case Instruction::Add:

784 case Instruction::FAdd:

785 case Instruction::Sub:

786 case Instruction::FSub:

787 case Instruction::Mul:

788 case Instruction::FMul:

789 case Instruction::UDiv:

790 case Instruction::SDiv:

791 case Instruction::URem:

792 case Instruction::SRem:

793 case Instruction::And:

794 case Instruction::Or:

795 case Instruction::Xor: {

799 switch (CE->getOperand(0)->getType()->getTypeID()) {

802 switch (CE->getOpcode()) {

804 case Instruction::Add: GV.IntVal = LHS.IntVal + RHS.IntVal; break;

805 case Instruction::Sub: GV.IntVal = LHS.IntVal - RHS.IntVal; break;

806 case Instruction::Mul: GV.IntVal = LHS.IntVal * RHS.IntVal; break;

807 case Instruction::UDiv:GV.IntVal = LHS.IntVal.udiv(RHS.IntVal); break;

808 case Instruction::SDiv:GV.IntVal = LHS.IntVal.sdiv(RHS.IntVal); break;

809 case Instruction::URem:GV.IntVal = LHS.IntVal.urem(RHS.IntVal); break;

810 case Instruction::SRem:GV.IntVal = LHS.IntVal.srem(RHS.IntVal); break;

811 case Instruction::And: GV.IntVal = LHS.IntVal & RHS.IntVal; break;

812 case Instruction::Or: GV.IntVal = LHS.IntVal | RHS.IntVal; break;

813 case Instruction::Xor: GV.IntVal = LHS.IntVal ^ RHS.IntVal; break;

814 }

815 break;

817 switch (CE->getOpcode()) {

819 case Instruction::FAdd:

821 case Instruction::FSub:

823 case Instruction::FMul:

825 case Instruction::FDiv:

827 case Instruction::FRem:

828 GV.FloatVal = std::fmod(LHS.FloatVal,RHS.FloatVal); break;

829 }

830 break;

832 switch (CE->getOpcode()) {

834 case Instruction::FAdd:

836 case Instruction::FSub:

838 case Instruction::FMul:

840 case Instruction::FDiv:

842 case Instruction::FRem:

843 GV.DoubleVal = std::fmod(LHS.DoubleVal,RHS.DoubleVal); break;

844 }

845 break;

849 const fltSemantics &Sem = CE->getOperand(0)->getType()->getFltSemantics();

851 switch (CE->getOpcode()) {

853 case Instruction::FAdd:

856 break;

857 case Instruction::FSub:

861 break;

862 case Instruction::FMul:

866 break;

867 case Instruction::FDiv:

871 break;

872 case Instruction::FRem:

875 break;

876 }

877 }

878 break;

879 }

880 return GV;

881 }

882 default:

883 break;

884 }

885

888 OS << "ConstantExpr not handled: " << *CE;

890 }

891

892 if (auto *TETy = dyn_cast(C->getType())) {

894 "TargetExtType only supports null constant value");

896 }

897

898

900 switch (C->getType()->getTypeID()) {

902 Result.FloatVal = cast(C)->getValueAPF().convertToFloat();

903 break;

905 Result.DoubleVal = cast(C)->getValueAPF().convertToDouble();

906 break;

910 Result.IntVal = cast (C)->getValueAPF().bitcastToAPInt();

911 break;

913 Result.IntVal = cast(C)->getValue();

914 break;

916 while (auto *A = dyn_cast(C)) {

917 C = A->getAliasee();

918 }

919 if (isa(C))

920 Result.PointerVal = nullptr;

921 else if (const Function *F = dyn_cast(C))

923 else if (const GlobalVariable *GV = dyn_cast(C))

925 else

927 break;

930 "Scalable vector support not yet implemented in ExecutionEngine");

932 unsigned elemNum;

933 Type* ElemTy;

937

938 if (CDV) {

941 } else if (CV || CAZ) {

942 auto *VTy = cast(C->getType());

943 elemNum = VTy->getNumElements();

944 ElemTy = VTy->getElementType();

945 } else {

947 }

948

949 Result.AggregateVal.resize(elemNum);

950

952 if (CAZ) {

955 std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),

956 floatZero);

957 break;

958 }

959 if(CV) {

960 for (unsigned i = 0; i < elemNum; ++i)

961 if (!isa(CV->getOperand(i)))

962 Result.AggregateVal[i].FloatVal = cast(

963 CV->getOperand(i))->getValueAPF().convertToFloat();

964 break;

965 }

966 if(CDV)

967 for (unsigned i = 0; i < elemNum; ++i)

969

970 break;

971 }

972

974 if (CAZ) {

977 std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),

978 doubleZero);

979 break;

980 }

981 if(CV) {

982 for (unsigned i = 0; i < elemNum; ++i)

983 if (!isa(CV->getOperand(i)))

984 Result.AggregateVal[i].DoubleVal = cast(

985 CV->getOperand(i))->getValueAPF().convertToDouble();

986 break;

987 }

988 if(CDV)

989 for (unsigned i = 0; i < elemNum; ++i)

991

992 break;

993 }

994

996 if (CAZ) {

999 std::fill(Result.AggregateVal.begin(), Result.AggregateVal.end(),

1000 intZero);

1001 break;

1002 }

1003 if(CV) {

1004 for (unsigned i = 0; i < elemNum; ++i)

1005 if (!isa(CV->getOperand(i)))

1006 Result.AggregateVal[i].IntVal = cast(

1008 else {

1009 Result.AggregateVal[i].IntVal =

1011 }

1012 break;

1013 }

1014 if(CDV)

1015 for (unsigned i = 0; i < elemNum; ++i)

1016 Result.AggregateVal[i].IntVal = APInt(

1019

1020 break;

1021 }

1023 } break;

1024

1025 default:

1028 OS << "ERROR: Constant unimplemented for type: " << *C->getType();

1030 }

1031

1032 return Result;

1033}

1034

1037

1038

1039 if (auto *TETy = dyn_cast(Ty))

1040 Ty = TETy->getLayoutType();

1041

1043

1045 default:

1046 dbgs() << "Cannot store value of type " << *Ty << "!\n";

1047 break;

1050 break;

1053 break;

1056 break;

1059 break;

1061

1062 if (StoreBytes != sizeof(PointerTy))

1063 memset(&(Ptr->PointerVal), 0, StoreBytes);

1064

1066 break;

1069 for (unsigned i = 0; i < Val.AggregateVal.size(); ++i) {

1070 if (cast(Ty)->getElementType()->isDoubleTy())

1072 if (cast(Ty)->getElementType()->isFloatTy())

1074 if (cast(Ty)->getElementType()->isIntegerTy()) {

1075 unsigned numOfBytes =(Val.AggregateVal[i].IntVal.getBitWidth()+7)/8;

1077 (uint8_t*)Ptr + numOfBytes*i, numOfBytes);

1078 }

1079 }

1080 break;

1081 }

1082

1084

1086}

1087

1088

1089

1093 if (auto *TETy = dyn_cast(Ty))

1094 Ty = TETy->getLayoutType();

1095

1097

1100

1101 Result.IntVal = APInt(cast(Ty)->getBitWidth(), 0);

1103 break;

1105 Result.FloatVal = *((float*)Ptr);

1106 break;

1108 Result.DoubleVal = *((double*)Ptr);

1109 break;

1112 break;

1114

1115

1117 memcpy(y, Ptr, 10);

1118 Result.IntVal = APInt(80, y);

1119 break;

1120 }

1123 "Scalable vector support not yet implemented in ExecutionEngine");

1125 auto *VT = cast(Ty);

1126 Type *ElemT = VT->getElementType();

1127 const unsigned numElems = VT->getNumElements();

1129 Result.AggregateVal.resize(numElems);

1130 for (unsigned i = 0; i < numElems; ++i)

1131 Result.AggregateVal[i].FloatVal = *((float*)Ptr+i);

1132 }

1134 Result.AggregateVal.resize(numElems);

1135 for (unsigned i = 0; i < numElems; ++i)

1136 Result.AggregateVal[i].DoubleVal = *((double*)Ptr+i);

1137 }

1140 const unsigned elemBitWidth = cast(ElemT)->getBitWidth();

1141 intZero.IntVal = APInt(elemBitWidth, 0);

1142 Result.AggregateVal.resize(numElems, intZero);

1143 for (unsigned i = 0; i < numElems; ++i)

1145 (uint8_t*)Ptr+((elemBitWidth+7)/8)*i, (elemBitWidth+7)/8);

1146 }

1147 break;

1148 }

1149 default:

1152 OS << "Cannot load value of type " << *Ty << "!";

1154 }

1155}

1156

1160 if (isa(Init))

1161 return;

1162

1164 unsigned ElementSize =

1166 for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i)

1168 return;

1169 }

1170

1171 if (isa(Init)) {

1173 return;

1174 }

1175

1177 unsigned ElementSize =

1179 for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i)

1181 return;

1182 }

1183

1187 for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i)

1189 return;

1190 }

1191

1193 dyn_cast(Init)) {

1194

1197 return;

1198 }

1199

1200 if (Init->getType()->isFirstClassType()) {

1203 return;

1204 }

1205

1207 llvm_unreachable("Unknown constant type to initialize memory with!");

1208}

1209

1210

1211

1212

1214

1215

1216

1217 std::map<std::pair<std::string, Type*>,

1219

1220 if (Modules.size() != 1) {

1221 for (const auto &M : Modules) {

1222 for (const auto &GV : M->globals()) {

1225 continue;

1226

1227 const GlobalValue *&GVEntry = LinkedGlobalsMap[std::make_pair(

1229

1230

1231

1232 if (!GVEntry) {

1233 GVEntry = &GV;

1234 continue;

1235 }

1236

1237

1239 continue;

1240

1241

1242

1244 GVEntry = &GV;

1245 }

1246 }

1247 }

1248

1249 std::vector<const GlobalValue*> NonCanonicalGlobals;

1250 for (const auto &M : Modules) {

1251 for (const auto &GV : M->globals()) {

1252

1253 if (!LinkedGlobalsMap.empty()) {

1254 if (const GlobalValue *GVEntry = LinkedGlobalsMap[std::make_pair(

1256

1257 if (GVEntry != &GV) {

1258 NonCanonicalGlobals.push_back(&GV);

1259 continue;

1260 }

1261 }

1262 }

1263

1266 } else {

1267

1268

1270 std::string(GV.getName())))

1272 else {

1275 }

1276 }

1277 }

1278

1279

1280

1281 if (!NonCanonicalGlobals.empty()) {

1282 for (const GlobalValue *GV : NonCanonicalGlobals) {

1283 const GlobalValue *CGV = LinkedGlobalsMap[std::make_pair(

1286 assert(Ptr && "Canonical global wasn't codegen'd!");

1288 }

1289 }

1290

1291

1292

1293 for (const auto &GV : M->globals()) {

1295 if (!LinkedGlobalsMap.empty()) {

1296 if (const GlobalValue *GVEntry = LinkedGlobalsMap[std::make_pair(

1298 if (GVEntry != &GV)

1299 continue;

1300 }

1302 }

1303 }

1304 }

1305}

1306

1307

1308

1309

1312

1313 if (!GA) {

1314

1316

1317

1318 if (!GA) return;

1319

1321 }

1322

1323

1326

1329 NumInitBytes += (unsigned)GVSize;

1330 ++NumGlobals;

1331}

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

static bool isTargetNullPtr(ExecutionEngine *EE, void *Loc)

isTargetNullPtr - Return whether the target pointer stored at Loc is null.

Module.h This file contains the declarations for the Module class.

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

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)

static unsigned getBitWidth(Type *Ty, const DataLayout &DL)

Returns the bitwidth of the given scalar or pointer type.

opStatus divide(const APFloat &RHS, roundingMode RM)

opStatus subtract(const APFloat &RHS, roundingMode RM)

opStatus add(const APFloat &RHS, roundingMode RM)

opStatus convertFromAPInt(const APInt &Input, bool IsSigned, roundingMode RM)

opStatus multiply(const APFloat &RHS, roundingMode RM)

APInt bitcastToAPInt() const

opStatus convertToInteger(MutableArrayRef< integerPart > Input, unsigned int Width, bool IsSigned, roundingMode RM, bool *IsExact) const

opStatus mod(const APFloat &RHS)

static APFloat getZero(const fltSemantics &Sem, bool Negative=false)

Factory for Positive and Negative Zero.

Class for arbitrary precision integers.

APInt zext(unsigned width) const

Zero extend to a new width.

uint64_t getZExtValue() const

Get zero extended value.

APInt zextOrTrunc(unsigned width) const

Zero extend or truncate to width.

APInt trunc(unsigned width) const

Truncate to new width.

static APInt floatToBits(float V)

Converts a float to APInt bits.

unsigned getBitWidth() const

Return the number of bits in the APInt.

double signedRoundToDouble() const

Converts this signed APInt to a double value.

float bitsToFloat() const

Converts APInt bits to a float.

static APInt doubleToBits(double V)

Converts a double to APInt bits.

APInt sext(unsigned width) const

Sign extend to a new width.

double bitsToDouble() const

Converts APInt bits to a double.

const uint64_t * getRawData() const

This function returns a pointer to the internal storage of the APInt.

double roundToDouble(bool isSigned) const

Converts this APInt to a double value.

Value handle with callbacks on RAUW and destruction.

All zero aggregate value.

ConstantArray - Constant Array Declarations.

ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...

double getElementAsDouble(unsigned i) const

If this is an sequential container of doubles, return the specified element as a double.

float getElementAsFloat(unsigned i) const

If this is an sequential container of floats, return the specified element as a float.

uint64_t getElementAsInteger(unsigned i) const

If this is a sequential container of integers (of any size), return the specified element in the low ...

unsigned getNumElements() const

Return the number of elements in the array or vector.

Type * getElementType() const

Return the element type of the array/vector.

A vector constant whose element type is a simple 1/2/4/8-byte integer or float/double,...

A constant value that is initialized with an expression using other constant values.

Constant Vector Declarations.

This is an important base class in LLVM.

static Constant * getNullValue(Type *Ty)

Constructor to create a '0' constant of arbitrary type.

A parsed version of the target data layout string in and methods for querying it.

unsigned getPointerSizeInBits(unsigned AS=0) const

Layout pointer size, in bits FIXME: The defaults need to be removed once all of the backends/clients ...

bool isDefault() const

Test if the DataLayout was constructed from an empty string.

const StructLayout * getStructLayout(StructType *Ty) const

Returns a StructLayout object, indicating the alignment of the struct, its size, and the offsets of i...

TypeSize getTypeAllocSize(Type *Ty) const

Returns the offset in bytes between successive objects of the specified type, including alignment pad...

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.

TypeSize getTypeSizeInBits(Type *Ty) const

Size examples:

TypeSize getTypeStoreSize(Type *Ty) const

Returns the maximum number of bytes that may be overwritten by storing the specified type.

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 ~ExecutionEngine()

virtual Function * FindFunctionNamed(StringRef FnName)

FindFunctionNamed - Search all of the active modules to find the function that defines FnName.

Class to represent function types.

unsigned getNumParams() const

Return the number of fixed parameters this function type requires.

Type * getParamType(unsigned i) const

Parameter type accessors.

Type * getReturnType() const

FunctionType * getFunctionType() const

Returns the FunctionType for me.

LLVMContext & getContext() const

getContext - Return a reference to the LLVMContext associated with this function.

bool hasExternalLinkage() const

bool isThreadLocal() const

If the value is "Thread Local", its value isn't shared by the threads.

bool isDeclaration() const

Return true if the primary definition of this global value is outside of the current translation unit...

bool hasLocalLinkage() const

bool hasExternalWeakLinkage() const

PointerType * getType() const

Global values are always pointers.

const DataLayout & getDataLayout() const

Get the data layout of the module this global belongs to.

bool hasAppendingLinkage() const

Type * getValueType() const

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.

This is an important class for using LLVM in a threaded context.

void getNameWithPrefix(raw_ostream &OS, const GlobalValue *GV, bool CannotUsePrivateLabel) const

Print the appropriate prefix and the specified global variable's name.

A Module instance is used to store all the information related to an LLVM module.

MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...

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...

Interface for looking up the initializer for a variable name, used by Init::resolveReferences.

SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...

iterator find(StringRef Key)

StringRef - Represent a constant reference to a string, i.e.

Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...

TypeSize getElementOffset(unsigned Idx) const

Class to represent struct types.

@ HasZeroInit

zeroinitializer is valid for this target extension type.

Primary interface to the complete machine description for the target machine.

The instances of the Type class are immutable: once they are created, they are never changed.

bool isX86_FP80Ty() const

Return true if this is x86 long double.

bool isPointerTy() const

True if this is an instance of PointerType.

bool isFloatTy() const

Return true if this is 'float', a 32-bit IEEE fp type.

@ ScalableVectorTyID

Scalable SIMD vector type.

@ FloatTyID

32-bit floating point type

@ IntegerTyID

Arbitrary bit width integers.

@ FixedVectorTyID

Fixed width SIMD vector type.

@ DoubleTyID

64-bit floating point type

@ X86_FP80TyID

80-bit floating point type (X87)

@ PPC_FP128TyID

128-bit floating point type (two 64-bits, PowerPC)

@ FP128TyID

128-bit floating point type (112-bit significand)

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.

bool isDoubleTy() const

Return true if this is 'double', a 64-bit IEEE fp type.

bool isFloatingPointTy() const

Return true if this is one of the floating-point types.

bool isIntegerTy() const

True if this is an instance of IntegerType.

TypeID getTypeID() const

Return the type id for the type.

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'.

static UndefValue * get(Type *T)

Static factory methods - Return an 'undef' object of the specified type.

Value * getOperand(unsigned i) const

unsigned getNumOperands() const

Type * getType() const

All values are typed, get the type of this value.

StringRef getName() const

Return a constant reference to the value's name.

A raw_ostream that writes to an SmallVector or SmallString.

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.

APInt RoundDoubleToAPInt(double Double, unsigned width)

Converts the given double value into a APInt.

@ C

The default llvm calling convention, compatible with C.

const_iterator begin(StringRef path LLVM_LIFETIME_BOUND, Style style=Style::native)

Get begin iterator over path.

const_iterator end(StringRef path LLVM_LIFETIME_BOUND)

Get end iterator over path.

static const bool IsLittleEndianHost

This is an optimization pass for GlobalISel generic memory operations.

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...

GenericValue PTOGV(void *P)

raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

void report_fatal_error(Error Err, bool gen_crash_diag=true)

Report a serious error, calling any installed error handler.

CodeGenOptLevel

Code generation optimization level.

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.

constexpr unsigned BitWidth

OutputIt move(R &&Range, OutputIt Out)

Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.

void * GVTOP(const GenericValue &GV)

@ 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,...

Implement std::hash so that hash_code can be used in STL containers.

static constexpr roundingMode rmNearestTiesToEven

static constexpr roundingMode rmTowardZero

static const fltSemantics & x87DoubleExtended() LLVM_READNONE

std::vector< GenericValue > AggregateVal