src/gallium/drivers/swr/rasterizer/jitter/JitManager.cpp

   1 /****************************************************************************
   2 * Copyright (C) 2014-2015 Intel Corporation.   All Rights Reserved.
   3 *
   4 * Permission is hereby granted, free of charge, to any person obtaining a
   5 * copy of this software and associated documentation files (the "Software"),
   6 * to deal in the Software without restriction, including without limitation
   7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8 * and/or sell copies of the Software, and to permit persons to whom the
   9 * Software is furnished to do so, subject to the following conditions:
  10 *
  11 * The above copyright notice and this permission notice (including the next
  12 * paragraph) shall be included in all copies or substantial portions of the
  13 * Software.
  14 *
  15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21 * IN THE SOFTWARE.
  22 *
  23 * @file JitManager.cpp
  24 *
  25 * @brief Implementation if the Jit Manager.
  26 *
  27 * Notes:
  28 *
  29 ******************************************************************************/
  30 #include "jit_pch.hpp"
  31
  32 #include "JitManager.h"
  33 #include "jit_api.h"
  34 #include "fetch_jit.h"
  35
  36 #include "core/state.h"
  37
  38 #include "gen_state_llvm.h"
  39
  40 #include <sstream>
  41 #if defined(_WIN32)
  42 #include <psapi.h>
  43 #include <cstring>
  44
  45 #define INTEL_OUTPUT_DIR "c:\\Intel"
  46 #define SWR_OUTPUT_DIR INTEL_OUTPUT_DIR "\\SWR"
  47 #define JITTER_OUTPUT_DIR SWR_OUTPUT_DIR "\\Jitter"
  48 #endif // _WIN32
  49
  50 #if defined(__APPLE) || defined(FORCE_LINUX) || defined(__linux__) || defined(__gnu_linux__)
  51 #include <pwd.h>
  52 #include <sys/stat.h>
  53 #endif
  54
  55
  56 using namespace llvm;
  57 using namespace SwrJit;
  58
  59 //////////////////////////////////////////////////////////////////////////
  60 /// @brief Contructor for JitManager.
  61 /// @param simdWidth - SIMD width to be used in generated program.
  62 JitManager::JitManager(uint32_t simdWidth, const char *arch, const char* core)
  63     : mContext(), mBuilder(mContext), mIsModuleFinalized(true), mJitNumber(0), mVWidth(simdWidth), mArch(arch)
  64 {
  65     InitializeNativeTarget();
  66     InitializeNativeTargetAsmPrinter();
  67     InitializeNativeTargetDisassembler();
  68
  69     TargetOptions    tOpts;
  70     tOpts.AllowFPOpFusion = FPOpFusion::Fast;
  71     tOpts.NoInfsFPMath = false;
  72     tOpts.NoNaNsFPMath = false;
  73     tOpts.UnsafeFPMath = false;
  74 #if defined(_DEBUG)
  75 #if LLVM_VERSION_MAJOR == 3 && LLVM_VERSION_MINOR < 7
  76     tOpts.NoFramePointerElim = true;
  77 #endif
  78 #endif
  79
  80     //tOpts.PrintMachineCode    = true;
  81
  82     mCore = std::string(core);
  83     std::transform(mCore.begin(), mCore.end(), mCore.begin(), ::tolower);
  84
  85     std::unique_ptr<Module> newModule(new Module("", mContext));
  86     mpCurrentModule = newModule.get();
  87
  88     StringRef hostCPUName;
  89
  90     hostCPUName = sys::getHostCPUName();
  91
  92 #if defined(_WIN32)
  93     // Needed for MCJIT on windows
  94     Triple hostTriple(sys::getProcessTriple());
  95     hostTriple.setObjectFormat(Triple::COFF);
  96     mpCurrentModule->setTargetTriple(hostTriple.getTriple());
  97 #endif // _WIN32
  98
  99     auto optLevel = CodeGenOpt::Aggressive;
 100
 101     mpExec = EngineBuilder(std::move(newModule))
 102         .setTargetOptions(tOpts)
 103         .setOptLevel(optLevel)
 104         .setMCPU(hostCPUName)
 105         .create();
 106
 107     if (KNOB_JIT_ENABLE_CACHE)
 108     {
 109         mCache.Init(this, hostCPUName, optLevel);
 110         mpExec->setObjectCache(&mCache);
 111     }
 112
 113 #if LLVM_USE_INTEL_JITEVENTS
 114     JITEventListener *vTune = JITEventListener::createIntelJITEventListener();
 115     mpExec->RegisterJITEventListener(vTune);
 116 #endif
 117
 118     mFP32Ty = Type::getFloatTy(mContext);   // float type
 119     mInt8Ty = Type::getInt8Ty(mContext);
 120     mInt32Ty = Type::getInt32Ty(mContext);   // int type
 121     mInt64Ty = Type::getInt64Ty(mContext);   // int type
 122
 123     // fetch function signature
 124 #if USE_SIMD16_SHADERS
 125     // typedef void(__cdecl *PFN_FETCH_FUNC)(SWR_FETCH_CONTEXT& fetchInfo, simd16vertex& out);
 126 #else
 127     // typedef void(__cdecl *PFN_FETCH_FUNC)(SWR_FETCH_CONTEXT& fetchInfo, simdvertex& out);
 128 #endif
 129     std::vector<Type*> fsArgs;
 130
 131     // llvm5 is picky and does not take a void * type
 132     fsArgs.push_back(PointerType::get(Gen_SWR_FETCH_CONTEXT(this), 0));
 133
 134     fsArgs.push_back(PointerType::get(Gen_SWR_FETCH_CONTEXT(this), 0));
 135 #if USE_SIMD16_SHADERS
 136     fsArgs.push_back(PointerType::get(Gen_simd16vertex(this), 0));
 137 #else
 138     fsArgs.push_back(PointerType::get(Gen_simdvertex(this), 0));
 139 #endif
 140
 141     mFetchShaderTy = FunctionType::get(Type::getVoidTy(mContext), fsArgs, false);
 142
 143     mSimtFP32Ty = VectorType::get(mFP32Ty, mVWidth);
 144     mSimtInt32Ty = VectorType::get(mInt32Ty, mVWidth);
 145
 146     mSimdVectorTy = ArrayType::get(mSimtFP32Ty, 4);
 147     mSimdVectorInt32Ty = ArrayType::get(mSimtInt32Ty, 4);
 148
 149 #if USE_SIMD16_SHADERS
 150     mSimd16FP32Ty = ArrayType::get(mSimtFP32Ty, 2);
 151     mSimd16Int32Ty = ArrayType::get(mSimtInt32Ty, 2);
 152
 153     mSimd16VectorFP32Ty = ArrayType::get(mSimd16FP32Ty, 4);
 154     mSimd16VectorInt32Ty = ArrayType::get(mSimd16Int32Ty, 4);
 155
 156 #endif
 157 #if defined(_WIN32)
 158     // explicitly instantiate used symbols from potentially staticly linked libs
 159     sys::DynamicLibrary::AddSymbol("exp2f", &exp2f);
 160     sys::DynamicLibrary::AddSymbol("log2f", &log2f);
 161     sys::DynamicLibrary::AddSymbol("sinf", &sinf);
 162     sys::DynamicLibrary::AddSymbol("cosf", &cosf);
 163     sys::DynamicLibrary::AddSymbol("powf", &powf);
 164 #endif
 165
 166 #if defined(_WIN32)
 167     if (KNOB_DUMP_SHADER_IR)
 168     {
 169         CreateDirectoryPath(INTEL_OUTPUT_DIR);
 170         CreateDirectoryPath(SWR_OUTPUT_DIR);
 171         CreateDirectoryPath(JITTER_OUTPUT_DIR);
 172     }
 173 #endif
 174 }
 175
 176 //////////////////////////////////////////////////////////////////////////
 177 /// @brief Create new LLVM module.
 178 void JitManager::SetupNewModule()
 179 {
 180     SWR_ASSERT(mIsModuleFinalized == true && "Current module is not finalized!");
 181
 182     std::unique_ptr<Module> newModule(new Module("", mContext));
 183     mpCurrentModule = newModule.get();
 184 #if defined(_WIN32)
 185     // Needed for MCJIT on windows
 186     Triple hostTriple(sys::getProcessTriple());
 187     hostTriple.setObjectFormat(Triple::COFF);
 188     newModule->setTargetTriple(hostTriple.getTriple());
 189 #endif // _WIN32
 190
 191     mpExec->addModule(std::move(newModule));
 192     mIsModuleFinalized = false;
 193 }
 194
 195
 196 DIType* JitManager::CreateDebugStructType(StructType* pType, const std::string& name, DIFile* pFile, uint32_t lineNum,
 197     const std::vector<std::pair<std::string, uint32_t>>& members)
 198 {
 199     DIBuilder builder(*mpCurrentModule);
 200     SmallVector<Metadata*, 8> ElemTypes;
 201     DataLayout DL = DataLayout(mpCurrentModule);
 202     uint32_t size = DL.getTypeAllocSizeInBits(pType);
 203     uint32_t alignment = DL.getABITypeAlignment(pType);
 204     DINode::DIFlags flags = DINode::DIFlags::FlagPublic;
 205
 206     DICompositeType* pDIStructTy = builder.createStructType(pFile, name, pFile, lineNum, size, alignment,
 207         flags, nullptr, builder.getOrCreateArray(ElemTypes));
 208
 209     // Register mapping now to break loops (in case struct contains itself or pointers to itself)
 210     mDebugStructMap[pType] = pDIStructTy;
 211
 212     uint32_t idx = 0;
 213     for (auto& elem : pType->elements())
 214     {
 215         std::string name = members[idx].first;
 216         uint32_t lineNum = members[idx].second;
 217         size = DL.getTypeAllocSizeInBits(elem);
 218         alignment = DL.getABITypeAlignment(elem);
 219         uint32_t offset = DL.getStructLayout(pType)->getElementOffsetInBits(idx);
 220         llvm::DIType* pDebugTy = GetDebugType(elem);
 221         ElemTypes.push_back(builder.createMemberType(pDIStructTy, name, pFile, lineNum, size, alignment, offset, flags, pDebugTy));
 222
 223         idx++;
 224     }
 225
 226     pDIStructTy->replaceElements(builder.getOrCreateArray(ElemTypes));
 227     return pDIStructTy;
 228 }
 229
 230 DIType* JitManager::GetDebugArrayType(Type* pTy)
 231 {
 232     DIBuilder builder(*mpCurrentModule);
 233     DataLayout DL = DataLayout(mpCurrentModule);
 234     ArrayType* pArrayTy = cast<ArrayType>(pTy);
 235     uint32_t size = DL.getTypeAllocSizeInBits(pArrayTy);
 236     uint32_t alignment = DL.getABITypeAlignment(pArrayTy);
 237
 238     SmallVector<Metadata*, 8> Elems;
 239     Elems.push_back(builder.getOrCreateSubrange(0, pArrayTy->getNumElements()));
 240     return builder.createArrayType(size, alignment, GetDebugType(pArrayTy->getElementType()), builder.getOrCreateArray(Elems));
 241 }
 242
 243 // Create a DIType from llvm Type
 244 DIType* JitManager::GetDebugType(Type* pTy)
 245 {
 246     DIBuilder builder(*mpCurrentModule);
 247     Type::TypeID id = pTy->getTypeID();
 248
 249     switch (id)
 250     {
 251     case Type::VoidTyID: return builder.createUnspecifiedType("void"); break;
 252 #if LLVM_VERSION_MAJOR >= 4
 253     case Type::HalfTyID: return builder.createBasicType("float16", 16, dwarf::DW_ATE_float); break;
 254     case Type::FloatTyID: return builder.createBasicType("float", 32, dwarf::DW_ATE_float); break;
 255     case Type::DoubleTyID: return builder.createBasicType("double", 64, dwarf::DW_ATE_float); break;
 256 #else
 257     case Type::HalfTyID: return builder.createBasicType("float16", 16, 0, dwarf::DW_ATE_float); break;
 258     case Type::FloatTyID: return builder.createBasicType("float", 32, 0, dwarf::DW_ATE_float); break;
 259     case Type::DoubleTyID: return builder.createBasicType("double", 64, 0, dwarf::DW_ATE_float); break;
 260 #endif
 261     case Type::IntegerTyID: return GetDebugIntegerType(pTy); break;
 262     case Type::StructTyID: return GetDebugStructType(pTy); break;
 263     case Type::ArrayTyID: return GetDebugArrayType(pTy); break;
 264     case Type::PointerTyID: return builder.createPointerType(GetDebugType(pTy->getPointerElementType()), 64, 64); break;
 265     case Type::VectorTyID: return GetDebugVectorType(pTy); break;
 266     case Type::FunctionTyID: return GetDebugFunctionType(pTy); break;
 267     default: SWR_ASSERT(false, "Unimplemented llvm type");
 268     }
 269     return nullptr;
 270 }
 271
 272 // Create a DISubroutineType from an llvm FunctionType
 273 DIType* JitManager::GetDebugFunctionType(Type* pTy)
 274 {
 275     SmallVector<Metadata*, 8> ElemTypes;
 276     FunctionType* pFuncTy = cast<FunctionType>(pTy);
 277     DIBuilder builder(*mpCurrentModule);
 278
 279     // Add result type
 280     ElemTypes.push_back(GetDebugType(pFuncTy->getReturnType()));
 281
 282     // Add arguments
 283     for (auto& param : pFuncTy->params())
 284     {
 285         ElemTypes.push_back(GetDebugType(param));
 286     }
 287
 288     return builder.createSubroutineType(builder.getOrCreateTypeArray(ElemTypes));
 289 }
 290
 291 DIType* JitManager::GetDebugIntegerType(Type* pTy)
 292 {
 293     DIBuilder builder(*mpCurrentModule);
 294     IntegerType* pIntTy = cast<IntegerType>(pTy);
 295     switch (pIntTy->getBitWidth())
 296     {
 297 #if LLVM_VERSION_MAJOR >= 4
 298     case 1: return builder.createBasicType("int1", 1, dwarf::DW_ATE_unsigned); break;
 299     case 8: return builder.createBasicType("int8", 8, dwarf::DW_ATE_signed); break;
 300     case 16: return builder.createBasicType("int16", 16, dwarf::DW_ATE_signed); break;
 301     case 32: return builder.createBasicType("int", 32, dwarf::DW_ATE_signed); break;
 302     case 64: return builder.createBasicType("int64", 64, dwarf::DW_ATE_signed); break;
 303 #else
 304     case 1: return builder.createBasicType("int1", 1, 0, dwarf::DW_ATE_unsigned); break;
 305     case 8: return builder.createBasicType("int8", 8, 0, dwarf::DW_ATE_signed); break;
 306     case 16: return builder.createBasicType("int16", 16, 0, dwarf::DW_ATE_signed); break;
 307     case 32: return builder.createBasicType("int", 32, 0, dwarf::DW_ATE_signed); break;
 308     case 64: return builder.createBasicType("int64", 64, 0, dwarf::DW_ATE_signed); break;
 309 #endif
 310     default: SWR_ASSERT(false, "Unimplemented integer bit width");
 311     }
 312     return nullptr;
 313 }
 314
 315 DIType* JitManager::GetDebugVectorType(Type* pTy)
 316 {
 317     DIBuilder builder(*mpCurrentModule);
 318     VectorType* pVecTy = cast<VectorType>(pTy);
 319     DataLayout DL = DataLayout(mpCurrentModule);
 320     uint32_t size = DL.getTypeAllocSizeInBits(pVecTy);
 321     uint32_t alignment = DL.getABITypeAlignment(pVecTy);
 322     SmallVector<Metadata*, 1> Elems;
 323     Elems.push_back(builder.getOrCreateSubrange(0, pVecTy->getVectorNumElements()));
 324
 325     return builder.createVectorType(size, alignment, GetDebugType(pVecTy->getVectorElementType()), builder.getOrCreateArray(Elems));
 326
 327 }
 328
 329 //////////////////////////////////////////////////////////////////////////
 330 /// @brief Dump function x86 assembly to file.
 331 /// @note This should only be called after the module has been jitted to x86 and the
 332 ///       module will not be further accessed.
 333 void JitManager::DumpAsm(Function* pFunction, const char* fileName)
 334 {
 335     if (KNOB_DUMP_SHADER_IR)
 336     {
 337
 338 #if defined(_WIN32)
 339         DWORD pid = GetCurrentProcessId();
 340         char procname[MAX_PATH];
 341         GetModuleFileNameA(NULL, procname, MAX_PATH);
 342         const char* pBaseName = strrchr(procname, '\\');
 343         std::stringstream outDir;
 344         outDir << JITTER_OUTPUT_DIR << pBaseName << "_" << pid << std::ends;
 345         CreateDirectoryPath(outDir.str().c_str());
 346 #endif
 347
 348         std::error_code EC;
 349         Module* pModule = pFunction->getParent();
 350         const char *funcName = pFunction->getName().data();
 351         char fName[256];
 352 #if defined(_WIN32)
 353         sprintf(fName, "%s\\%s.%s.asm", outDir.str().c_str(), funcName, fileName);
 354 #else
 355         sprintf(fName, "%s.%s.asm", funcName, fileName);
 356 #endif
 357
 358         raw_fd_ostream filestream(fName, EC, llvm::sys::fs::F_None);
 359
 360         legacy::PassManager* pMPasses = new legacy::PassManager();
 361         auto* pTarget = mpExec->getTargetMachine();
 362         pTarget->Options.MCOptions.AsmVerbose = true;
 363         pTarget->addPassesToEmitFile(*pMPasses, filestream, TargetMachine::CGFT_AssemblyFile);
 364         pMPasses->run(*pModule);
 365         delete pMPasses;
 366         pTarget->Options.MCOptions.AsmVerbose = false;
 367     }
 368 }
 369
 370 std::string JitManager::GetOutputDir()
 371 {
 372 #if defined(_WIN32)
 373     DWORD pid = GetCurrentProcessId();
 374     char procname[MAX_PATH];
 375     GetModuleFileNameA(NULL, procname, MAX_PATH);
 376     const char* pBaseName = strrchr(procname, '\\');
 377     std::stringstream outDir;
 378     outDir << JITTER_OUTPUT_DIR << pBaseName << "_" << pid;
 379     CreateDirectoryPath(outDir.str().c_str());
 380     return outDir.str();
 381 #endif
 382     return "";
 383 }
 384
 385 //////////////////////////////////////////////////////////////////////////
 386 /// @brief Dump function to file.
 387 void JitManager::DumpToFile(Module *M, const char *fileName)
 388 {
 389     if (KNOB_DUMP_SHADER_IR)
 390     {
 391         std::string outDir = GetOutputDir();
 392
 393         std::error_code EC;
 394         const char *funcName = M->getName().data();
 395         char fName[256];
 396 #if defined(_WIN32)
 397         sprintf(fName, "%s\\%s.%s.ll", outDir.c_str(), funcName, fileName);
 398 #else
 399         sprintf(fName, "%s.%s.ll", funcName, fileName);
 400 #endif
 401         raw_fd_ostream fd(fName, EC, llvm::sys::fs::F_None);
 402         M->print(fd, nullptr);
 403         fd.flush();
 404     }
 405 }
 406
 407 //////////////////////////////////////////////////////////////////////////
 408 /// @brief Dump function to file.
 409 void JitManager::DumpToFile(Function *f, const char *fileName)
 410 {
 411     if (KNOB_DUMP_SHADER_IR)
 412     {
 413         std::string outDir = GetOutputDir();
 414
 415         std::error_code EC;
 416         const char *funcName = f->getName().data();
 417         char fName[256];
 418 #if defined(_WIN32)
 419         sprintf(fName, "%s\\%s.%s.ll", outDir.c_str(), funcName, fileName);
 420 #else
 421         sprintf(fName, "%s.%s.ll", funcName, fileName);
 422 #endif
 423         raw_fd_ostream fd(fName, EC, llvm::sys::fs::F_None);
 424         Module* pModule = f->getParent();
 425         pModule->print(fd, nullptr);
 426
 427 #if defined(_WIN32)
 428         sprintf(fName, "%s\\cfg.%s.%s.dot", outDir.c_str(), funcName, fileName);
 429 #else
 430         sprintf(fName, "cfg.%s.%s.dot", funcName, fileName);
 431 #endif
 432         fd.flush();
 433
 434         raw_fd_ostream fd_cfg(fName, EC, llvm::sys::fs::F_Text);
 435         WriteGraph(fd_cfg, (const Function*)f);
 436
 437         fd_cfg.flush();
 438     }
 439 }
 440
 441 extern "C"
 442 {
 443     bool g_DllActive = true;
 444
 445     //////////////////////////////////////////////////////////////////////////
 446     /// @brief Create JIT context.
 447     /// @param simdWidth - SIMD width to be used in generated program.
 448     HANDLE JITCALL JitCreateContext(uint32_t targetSimdWidth, const char* arch, const char* core)
 449     {
 450         return new JitManager(targetSimdWidth, arch, core);
 451     }
 452
 453     //////////////////////////////////////////////////////////////////////////
 454     /// @brief Destroy JIT context.
 455     void JITCALL JitDestroyContext(HANDLE hJitContext)
 456     {
 457         if (g_DllActive)
 458         {
 459             delete reinterpret_cast<JitManager*>(hJitContext);
 460         }
 461     }
 462 }
 463
 464 //////////////////////////////////////////////////////////////////////////
 465 /// JitCache
 466 //////////////////////////////////////////////////////////////////////////
 467
 468 //////////////////////////////////////////////////////////////////////////
 469 /// JitCacheFileHeader
 470 //////////////////////////////////////////////////////////////////////////
 471 struct JitCacheFileHeader
 472 {
 473     void Init(
 474         uint32_t llCRC,
 475         uint32_t objCRC,
 476         const std::string& moduleID,
 477         const std::string& cpu,
 478         uint32_t optLevel,
 479         uint64_t objSize)
 480     {
 481         m_objSize = objSize;
 482         m_llCRC = llCRC;
 483         m_objCRC = objCRC;
 484         strncpy(m_ModuleID, moduleID.c_str(), JC_STR_MAX_LEN - 1);
 485         m_ModuleID[JC_STR_MAX_LEN - 1] = 0;
 486         strncpy(m_Cpu, cpu.c_str(), JC_STR_MAX_LEN - 1);
 487         m_Cpu[JC_STR_MAX_LEN - 1] = 0;
 488         m_optLevel = optLevel;
 489     }
 490
 491 #if defined(ENABLE_JIT_DEBUG)
 492     void Init(
 493         uint32_t llCRC,
 494         uint32_t objCRC,
 495         const std::string& moduleID,
 496         const std::string& cpu,
 497         uint32_t optLevel,
 498         uint64_t objSize,
 499         uint32_t modCRC,
 500         uint64_t modSize)
 501     {
 502         Init(llCRC, objCRC, moduleID, cpu, optLevel, objSize);
 503         m_modCRC = modCRC;
 504         m_modSize = modSize;
 505     }
 506
 507     void Init(
 508         uint32_t modCRC,
 509         uint64_t modSize)
 510     {
 511         m_modCRC = modCRC;
 512         m_modSize = modSize;
 513     }
 514 #endif
 515
 516     bool IsValid(uint32_t llCRC, const std::string& moduleID, const std::string& cpu, uint32_t optLevel)
 517     {
 518         if ((m_MagicNumber != JC_MAGIC_NUMBER) ||
 519             (m_llCRC != llCRC) ||
 520             (m_platformKey != JC_PLATFORM_KEY) ||
 521             (m_optLevel != optLevel))
 522         {
 523             return false;
 524         }
 525
 526         m_ModuleID[JC_STR_MAX_LEN - 1] = 0;
 527         if (strncmp(moduleID.c_str(), m_ModuleID, JC_STR_MAX_LEN - 1))
 528         {
 529             return false;
 530         }
 531
 532         m_Cpu[JC_STR_MAX_LEN - 1] = 0;
 533         if (strncmp(cpu.c_str(), m_Cpu, JC_STR_MAX_LEN - 1))
 534         {
 535             return false;
 536         }
 537
 538         return true;
 539     }
 540
 541     uint64_t GetObjectSize() const { return m_objSize; }
 542     uint64_t GetObjectCRC() const { return m_objCRC; }
 543 #if defined(ENABLE_JIT_DEBUG)
 544     uint64_t GetSharedModuleSize() const { return m_modSize; }
 545     uint64_t GetSharedModuleCRC() const { return m_modCRC; }
 546 #endif
 547
 548 private:
 549     static const uint64_t   JC_MAGIC_NUMBER = 0xfedcba9876543211ULL + 3;
 550     static const size_t     JC_STR_MAX_LEN = 32;
 551     static const uint32_t   JC_PLATFORM_KEY =
 552         (LLVM_VERSION_MAJOR << 24)  |
 553         (LLVM_VERSION_MINOR << 16)  |
 554         (LLVM_VERSION_PATCH << 8)   |
 555         ((sizeof(void*) > sizeof(uint32_t)) ? 1 : 0);
 556
 557     uint64_t m_MagicNumber = JC_MAGIC_NUMBER;
 558     uint64_t m_objSize = 0;
 559     uint32_t m_llCRC = 0;
 560     uint32_t m_platformKey = JC_PLATFORM_KEY;
 561     uint32_t m_objCRC = 0;
 562     uint32_t m_optLevel = 0;
 563     char m_ModuleID[JC_STR_MAX_LEN] = {};
 564     char m_Cpu[JC_STR_MAX_LEN] = {};
 565 #if defined(ENABLE_JIT_DEBUG)
 566     uint32_t m_modCRC = 0;
 567     uint64_t m_modSize = 0;
 568 #endif
 569 };
 570
 571 static inline uint32_t ComputeModuleCRC(const llvm::Module* M)
 572 {
 573     std::string bitcodeBuffer;
 574     raw_string_ostream bitcodeStream(bitcodeBuffer);
 575
 576     llvm::WriteBitcodeToFile(M, bitcodeStream);
 577     //M->print(bitcodeStream, nullptr, false);
 578
 579     bitcodeStream.flush();
 580
 581     return ComputeCRC(0, bitcodeBuffer.data(), bitcodeBuffer.size());
 582 }
 583
 584 /// constructor
 585 JitCache::JitCache()
 586 {
 587 #if defined(__APPLE) || defined(FORCE_LINUX) || defined(__linux__) || defined(__gnu_linux__)
 588     if (strncmp(KNOB_JIT_CACHE_DIR.c_str(), "~/", 2) == 0) {
 589         char *homedir;
 590         if (!(homedir = getenv("HOME"))) {
 591             homedir = getpwuid(getuid())->pw_dir;
 592         }
 593         mCacheDir = homedir;
 594         mCacheDir += (KNOB_JIT_CACHE_DIR.c_str() + 1);
 595     } else
 596 #endif
 597     {
 598         mCacheDir = KNOB_JIT_CACHE_DIR;
 599     }
 600 }
 601
 602 #if defined(_WIN32)
 603 int ExecUnhookedProcess(const char* pCmdLine)
 604 {
 605     static const char *g_pEnv = "RASTY_DISABLE_HOOK=1\0";
 606
 607     STARTUPINFOA StartupInfo{};
 608     StartupInfo.cb = sizeof(STARTUPINFOA);
 609     PROCESS_INFORMATION procInfo{};
 610
 611     BOOL ProcessValue = CreateProcessA(
 612         NULL,
 613         (LPSTR)pCmdLine,
 614         NULL,
 615         NULL,
 616         TRUE,
 617         0,
 618         (LPVOID)g_pEnv,
 619         NULL,
 620         &StartupInfo,
 621         &procInfo);
 622
 623     if (ProcessValue && procInfo.hProcess)
 624     {
 625         WaitForSingleObject(procInfo.hProcess, INFINITE);
 626         DWORD exitVal = 0;
 627         if (!GetExitCodeProcess(procInfo.hProcess, &exitVal))
 628         {
 629             exitVal = 1;
 630         }
 631
 632         CloseHandle(procInfo.hProcess);
 633
 634         return exitVal;
 635     }
 636
 637     return -1;
 638 }
 639 #endif
 640
 641 #if defined(_WIN64) && defined(ENABLE_JIT_DEBUG) && defined(JIT_BASE_DIR)
 642 EXTERN_C IMAGE_DOS_HEADER __ImageBase;
 643 static __inline HINSTANCE GetModuleHINSTANCE() { return (HINSTANCE)&__ImageBase; }
 644 #endif
 645
 646 /// notifyObjectCompiled - Provides a pointer to compiled code for Module M.
 647 void JitCache::notifyObjectCompiled(const llvm::Module *M, llvm::MemoryBufferRef Obj)
 648 {
 649     const std::string& moduleID = M->getModuleIdentifier();
 650     if (!moduleID.length())
 651     {
 652         return;
 653     }
 654
 655     if (!llvm::sys::fs::exists(mCacheDir.str()) &&
 656         llvm::sys::fs::create_directories(mCacheDir.str()))
 657     {
 658         SWR_INVALID("Unable to create directory: %s", mCacheDir.c_str());
 659         return;
 660     }
 661
 662     JitCacheFileHeader header;
 663
 664     llvm::SmallString<MAX_PATH> filePath = mCacheDir;
 665     llvm::sys::path::append(filePath, moduleID);
 666
 667     llvm::SmallString<MAX_PATH> objPath = filePath;
 668     objPath += JIT_OBJ_EXT;
 669
 670     {
 671         std::error_code err;
 672         llvm::raw_fd_ostream fileObj(objPath.c_str(), err, llvm::sys::fs::F_None);
 673         fileObj << Obj.getBuffer();
 674         fileObj.flush();
 675     }
 676
 677
 678     {
 679         std::error_code err;
 680         llvm::raw_fd_ostream fileObj(filePath.c_str(), err, llvm::sys::fs::F_None);
 681
 682         uint32_t objcrc = ComputeCRC(0, Obj.getBufferStart(), Obj.getBufferSize());
 683
 684         header.Init(mCurrentModuleCRC, objcrc, moduleID, mCpu, mOptLevel, Obj.getBufferSize());
 685
 686         fileObj.write((const char*)&header, sizeof(header));
 687         fileObj.flush();
 688     }
 689 }
 690
 691 /// Returns a pointer to a newly allocated MemoryBuffer that contains the
 692 /// object which corresponds with Module M, or 0 if an object is not
 693 /// available.
 694 std::unique_ptr<llvm::MemoryBuffer> JitCache::getObject(const llvm::Module* M)
 695 {
 696     const std::string& moduleID = M->getModuleIdentifier();
 697     mCurrentModuleCRC = ComputeModuleCRC(M);
 698
 699     if (!moduleID.length())
 700     {
 701         return nullptr;
 702     }
 703
 704     if (!llvm::sys::fs::exists(mCacheDir))
 705     {
 706         return nullptr;
 707     }
 708
 709     llvm::SmallString<MAX_PATH> filePath = mCacheDir;
 710     llvm::sys::path::append(filePath, moduleID);
 711
 712     llvm::SmallString<MAX_PATH> objFilePath = filePath;
 713     objFilePath += JIT_OBJ_EXT;
 714
 715 #if defined(ENABLE_JIT_DEBUG)
 716     FILE* fpModuleIn = nullptr;
 717 #endif
 718     FILE* fpObjIn = nullptr;
 719     FILE* fpIn = fopen(filePath.c_str(), "rb");
 720     if (!fpIn)
 721     {
 722         return nullptr;
 723     }
 724
 725     std::unique_ptr<llvm::MemoryBuffer> pBuf = nullptr;
 726     do
 727     {
 728         JitCacheFileHeader header;
 729         if (!fread(&header, sizeof(header), 1, fpIn))
 730         {
 731             break;
 732         }
 733
 734         if (!header.IsValid(mCurrentModuleCRC, moduleID, mCpu, mOptLevel))
 735         {
 736             break;
 737         }
 738
 739         fpObjIn = fopen(objFilePath.c_str(), "rb");
 740         if (!fpObjIn)
 741         {
 742             break;
 743         }
 744
 745 #if LLVM_VERSION_MAJOR < 6
 746         pBuf = llvm::MemoryBuffer::getNewUninitMemBuffer(size_t(header.GetObjectSize()));
 747 #else
 748         pBuf = llvm::WritableMemoryBuffer::getNewUninitMemBuffer(size_t(header.GetObjectSize()));
 749 #endif
 750         if (!fread(const_cast<char*>(pBuf->getBufferStart()), header.GetObjectSize(), 1, fpObjIn))
 751         {
 752             pBuf = nullptr;
 753             break;
 754         }
 755
 756         if (header.GetObjectCRC() != ComputeCRC(0, pBuf->getBufferStart(), pBuf->getBufferSize()))
 757         {
 758             SWR_TRACE("Invalid object cache file, ignoring: %s", filePath.c_str());
 759             pBuf = nullptr;
 760             break;
 761         }
 762
 763     }
 764     while (0);
 765
 766     fclose(fpIn);
 767
 768     if (fpObjIn)
 769     {
 770         fclose(fpObjIn);
 771     }
 772
 773 #if defined(ENABLE_JIT_DEBUG)
 774     if (fpModuleIn)
 775     {
 776         fclose(fpModuleIn);
 777     }
 778 #endif
 779
 780     return pBuf;
 781 }