1 //===-- ExecutionEngine.cpp - Common Implementation shared by EE's --------===// 2 // 3 // This file defines the common interface used by the various execution engine 4 // subclasses. 5 // 6 //===----------------------------------------------------------------------===// 7 8 #include "ExecutionEngine.h" 9 #include "GenericValue.h" 10 #include "llvm/DerivedTypes.h" 11 #include "llvm/Constants.h" 12 #include "llvm/Module.h" 13 #include "llvm/Target/TargetData.h" 14 #include "Support/Statistic.h" 15 #include <dlfcn.h> 16 17 Statistic<> NumInitBytes("lli", "Number of bytes of global vars initialized"); 18 19 // getPointerToGlobal - This returns the address of the specified global 20 // value. This may involve code generation if it's a function. 21 // 22 void *ExecutionEngine::getPointerToGlobal(const GlobalValue *GV) { 23 if (const Function *F = dyn_cast<Function>(GV)) 24 return getPointerToFunction(F); 25 26 assert(GlobalAddress[GV] && "Global hasn't had an address allocated yet?"); 27 return GlobalAddress[GV]; 28 } 29 30 31 GenericValue ExecutionEngine::getConstantValue(const Constant *C) { 32 GenericValue Result; 33 34 if (ConstantExpr *CE = (ConstantExpr*)dyn_cast<ConstantExpr>(C)) 35 switch (CE->getOpcode()) { 36 case Instruction::GetElementPtr: { 37 Result = getConstantValue(cast<Constant>(CE->getOperand(0))); 38 std::vector<Value*> Indexes(CE->op_begin()+1, CE->op_end()); 39 uint64_t Offset = 40 TD->getIndexedOffset(CE->getOperand(0)->getType(), Indexes); 41 42 Result.LongVal += Offset; 43 return Result; 44 } 45 46 default: 47 std::cerr << "ConstantExpr not handled as global var init: " << *CE 48 << "\n"; 49 abort(); 50 } 51 52 switch (C->getType()->getPrimitiveID()) { 53 #define GET_CONST_VAL(TY, CLASS) \ 54 case Type::TY##TyID: Result.TY##Val = cast<CLASS>(C)->getValue(); break 55 GET_CONST_VAL(Bool , ConstantBool); 56 GET_CONST_VAL(UByte , ConstantUInt); 57 GET_CONST_VAL(SByte , ConstantSInt); 58 GET_CONST_VAL(UShort , ConstantUInt); 59 GET_CONST_VAL(Short , ConstantSInt); 60 GET_CONST_VAL(UInt , ConstantUInt); 61 GET_CONST_VAL(Int , ConstantSInt); 62 GET_CONST_VAL(ULong , ConstantUInt); 63 GET_CONST_VAL(Long , ConstantSInt); 64 GET_CONST_VAL(Float , ConstantFP); 65 GET_CONST_VAL(Double , ConstantFP); 66 #undef GET_CONST_VAL 67 case Type::PointerTyID: 68 if (isa<ConstantPointerNull>(C)) { 69 Result.PointerVal = 0; 70 } else if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(C)){ 71 Result = PTOGV(getPointerToGlobal(CPR->getValue())); 72 73 } else { 74 assert(0 && "Unknown constant pointer type!"); 75 } 76 break; 77 default: 78 std::cout << "ERROR: Constant unimp for type: " << C->getType() << "\n"; 79 abort(); 80 } 81 return Result; 82 } 83 84 void ExecutionEngine::StoreValueToMemory(GenericValue Val, GenericValue *Ptr, 85 const Type *Ty) { 86 if (getTargetData().isLittleEndian()) { 87 switch (Ty->getPrimitiveID()) { 88 case Type::BoolTyID: 89 case Type::UByteTyID: 90 case Type::SByteTyID: Ptr->Untyped[0] = Val.UByteVal; break; 91 case Type::UShortTyID: 92 case Type::ShortTyID: Ptr->Untyped[0] = Val.UShortVal & 255; 93 Ptr->Untyped[1] = (Val.UShortVal >> 8) & 255; 94 break; 95 Store4BytesLittleEndian: 96 case Type::FloatTyID: 97 case Type::UIntTyID: 98 case Type::IntTyID: Ptr->Untyped[0] = Val.UIntVal & 255; 99 Ptr->Untyped[1] = (Val.UIntVal >> 8) & 255; 100 Ptr->Untyped[2] = (Val.UIntVal >> 16) & 255; 101 Ptr->Untyped[3] = (Val.UIntVal >> 24) & 255; 102 break; 103 case Type::PointerTyID: if (CurMod.has32BitPointers()) 104 goto Store4BytesLittleEndian; 105 case Type::DoubleTyID: 106 case Type::ULongTyID: 107 case Type::LongTyID: Ptr->Untyped[0] = Val.ULongVal & 255; 108 Ptr->Untyped[1] = (Val.ULongVal >> 8) & 255; 109 Ptr->Untyped[2] = (Val.ULongVal >> 16) & 255; 110 Ptr->Untyped[3] = (Val.ULongVal >> 24) & 255; 111 Ptr->Untyped[4] = (Val.ULongVal >> 32) & 255; 112 Ptr->Untyped[5] = (Val.ULongVal >> 40) & 255; 113 Ptr->Untyped[6] = (Val.ULongVal >> 48) & 255; 114 Ptr->Untyped[7] = (Val.ULongVal >> 56) & 255; 115 break; 116 default: 117 std::cout << "Cannot store value of type " << Ty << "!\n"; 118 } 119 } else { 120 switch (Ty->getPrimitiveID()) { 121 case Type::BoolTyID: 122 case Type::UByteTyID: 123 case Type::SByteTyID: Ptr->Untyped[0] = Val.UByteVal; break; 124 case Type::UShortTyID: 125 case Type::ShortTyID: Ptr->Untyped[1] = Val.UShortVal & 255; 126 Ptr->Untyped[0] = (Val.UShortVal >> 8) & 255; 127 break; 128 Store4BytesBigEndian: 129 case Type::FloatTyID: 130 case Type::UIntTyID: 131 case Type::IntTyID: Ptr->Untyped[3] = Val.UIntVal & 255; 132 Ptr->Untyped[2] = (Val.UIntVal >> 8) & 255; 133 Ptr->Untyped[1] = (Val.UIntVal >> 16) & 255; 134 Ptr->Untyped[0] = (Val.UIntVal >> 24) & 255; 135 break; 136 case Type::PointerTyID: if (CurMod.has32BitPointers()) 137 goto Store4BytesBigEndian; 138 case Type::DoubleTyID: 139 case Type::ULongTyID: 140 case Type::LongTyID: Ptr->Untyped[7] = Val.ULongVal & 255; 141 Ptr->Untyped[6] = (Val.ULongVal >> 8) & 255; 142 Ptr->Untyped[5] = (Val.ULongVal >> 16) & 255; 143 Ptr->Untyped[4] = (Val.ULongVal >> 24) & 255; 144 Ptr->Untyped[3] = (Val.ULongVal >> 32) & 255; 145 Ptr->Untyped[2] = (Val.ULongVal >> 40) & 255; 146 Ptr->Untyped[1] = (Val.ULongVal >> 48) & 255; 147 Ptr->Untyped[0] = (Val.ULongVal >> 56) & 255; 148 break; 149 default: 150 std::cout << "Cannot store value of type " << Ty << "!\n"; 151 } 152 } 153 } 154 155 // InitializeMemory - Recursive function to apply a Constant value into the 156 // specified memory location... 157 // 158 void ExecutionEngine::InitializeMemory(const Constant *Init, void *Addr) { 159 if (Init->getType()->isFirstClassType()) { 160 GenericValue Val = getConstantValue(Init); 161 StoreValueToMemory(Val, (GenericValue*)Addr, Init->getType()); 162 return; 163 } 164 165 switch (Init->getType()->getPrimitiveID()) { 166 case Type::ArrayTyID: { 167 const ConstantArray *CPA = cast<ConstantArray>(Init); 168 const std::vector<Use> &Val = CPA->getValues(); 169 unsigned ElementSize = 170 getTargetData().getTypeSize(cast<ArrayType>(CPA->getType())->getElementType()); 171 for (unsigned i = 0; i < Val.size(); ++i) 172 InitializeMemory(cast<Constant>(Val[i].get()), (char*)Addr+i*ElementSize); 173 return; 174 } 175 176 case Type::StructTyID: { 177 const ConstantStruct *CPS = cast<ConstantStruct>(Init); 178 const StructLayout *SL = 179 getTargetData().getStructLayout(cast<StructType>(CPS->getType())); 180 const std::vector<Use> &Val = CPS->getValues(); 181 for (unsigned i = 0; i < Val.size(); ++i) 182 InitializeMemory(cast<Constant>(Val[i].get()), 183 (char*)Addr+SL->MemberOffsets[i]); 184 return; 185 } 186 187 default: 188 std::cerr << "Bad Type: " << Init->getType() << "\n"; 189 assert(0 && "Unknown constant type to initialize memory with!"); 190 } 191 } 192 193 194 195 void *ExecutionEngine::CreateArgv(const std::vector<std::string> &InputArgv) { 196 if (getTargetData().getPointerSize() == 8) { // 64 bit target? 197 PointerTy *Result = new PointerTy[InputArgv.size()+1]; 198 DEBUG(std::cerr << "ARGV = " << (void*)Result << "\n"); 199 200 for (unsigned i = 0; i < InputArgv.size(); ++i) { 201 unsigned Size = InputArgv[i].size()+1; 202 char *Dest = new char[Size]; 203 DEBUG(std::cerr << "ARGV[" << i << "] = " << (void*)Dest << "\n"); 204 205 copy(InputArgv[i].begin(), InputArgv[i].end(), Dest); 206 Dest[Size-1] = 0; 207 208 // Endian safe: Result[i] = (PointerTy)Dest; 209 StoreValueToMemory(PTOGV(Dest), (GenericValue*)(Result+i), Type::LongTy); 210 } 211 Result[InputArgv.size()] = 0; 212 return Result; 213 214 } else { // 32 bit target? 215 int *Result = new int[InputArgv.size()+1]; 216 DEBUG(std::cerr << "ARGV = " << (void*)Result << "\n"); 217 218 for (unsigned i = 0; i < InputArgv.size(); ++i) { 219 unsigned Size = InputArgv[i].size()+1; 220 char *Dest = new char[Size]; 221 DEBUG(std::cerr << "ARGV[" << i << "] = " << (void*)Dest << "\n"); 222 223 copy(InputArgv[i].begin(), InputArgv[i].end(), Dest); 224 Dest[Size-1] = 0; 225 226 // Endian safe: Result[i] = (PointerTy)Dest; 227 StoreValueToMemory(PTOGV(Dest), (GenericValue*)(Result+i), Type::IntTy); 228 } 229 Result[InputArgv.size()] = 0; // null terminate it 230 return Result; 231 } 232 } 233 234 /// EmitGlobals - Emit all of the global variables to memory, storing their 235 /// addresses into GlobalAddress. This must make sure to copy the contents of 236 /// their initializers into the memory. 237 /// 238 void ExecutionEngine::emitGlobals() { 239 const TargetData &TD = getTargetData(); 240 241 // Loop over all of the global variables in the program, allocating the memory 242 // to hold them. 243 for (Module::giterator I = getModule().gbegin(), E = getModule().gend(); 244 I != E; ++I) 245 if (!I->isExternal()) { 246 // Get the type of the global... 247 const Type *Ty = I->getType()->getElementType(); 248 249 // Allocate some memory for it! 250 unsigned Size = TD.getTypeSize(Ty); 251 GlobalAddress[I] = new char[Size]; 252 NumInitBytes += Size; 253 254 DEBUG(std::cerr << "Global '" << I->getName() << "' -> " 255 << (void*)GlobalAddress[I] << "\n"); 256 } else { 257 // External variable reference, try to use dlsym to get a pointer to it in 258 // the LLI image. 259 if (void *SymAddr = dlsym(0, I->getName().c_str())) 260 GlobalAddress[I] = SymAddr; 261 else { 262 std::cerr << "Could not resolve external global address: " 263 << I->getName() << "\n"; 264 abort(); 265 } 266 } 267 268 // Now that all of the globals are set up in memory, loop through them all and 269 // initialize their contents. 270 for (Module::giterator I = getModule().gbegin(), E = getModule().gend(); 271 I != E; ++I) 272 if (!I->isExternal()) 273 InitializeMemory(I->getInitializer(), GlobalAddress[I]); 274 } 275 276