1 //===-- LLVMContext.cpp - Implement LLVMContext ---------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements LLVMContext, as a wrapper around the opaque 11 // class LLVMContextImpl. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "llvm/IR/LLVMContext.h" 16 #include "LLVMContextImpl.h" 17 #include "llvm/IR/Constants.h" 18 #include "llvm/IR/DebugLoc.h" 19 #include "llvm/IR/DiagnosticInfo.h" 20 #include "llvm/IR/DiagnosticPrinter.h" 21 #include "llvm/IR/Instruction.h" 22 #include "llvm/IR/Metadata.h" 23 #include "llvm/Support/ManagedStatic.h" 24 #include "llvm/Support/SourceMgr.h" 25 #include <cctype> 26 using namespace llvm; 27 28 static ManagedStatic<LLVMContext> GlobalContext; 29 30 LLVMContext& llvm::getGlobalContext() { 31 return *GlobalContext; 32 } 33 34 LLVMContext::LLVMContext() : pImpl(new LLVMContextImpl(*this)) { 35 // Create the fixed metadata kinds. This is done in the same order as the 36 // MD_* enum values so that they correspond. 37 38 // Create the 'dbg' metadata kind. 39 unsigned DbgID = getMDKindID("dbg"); 40 assert(DbgID == MD_dbg && "dbg kind id drifted"); (void)DbgID; 41 42 // Create the 'tbaa' metadata kind. 43 unsigned TBAAID = getMDKindID("tbaa"); 44 assert(TBAAID == MD_tbaa && "tbaa kind id drifted"); (void)TBAAID; 45 46 // Create the 'prof' metadata kind. 47 unsigned ProfID = getMDKindID("prof"); 48 assert(ProfID == MD_prof && "prof kind id drifted"); (void)ProfID; 49 50 // Create the 'fpmath' metadata kind. 51 unsigned FPAccuracyID = getMDKindID("fpmath"); 52 assert(FPAccuracyID == MD_fpmath && "fpmath kind id drifted"); 53 (void)FPAccuracyID; 54 55 // Create the 'range' metadata kind. 56 unsigned RangeID = getMDKindID("range"); 57 assert(RangeID == MD_range && "range kind id drifted"); 58 (void)RangeID; 59 60 // Create the 'tbaa.struct' metadata kind. 61 unsigned TBAAStructID = getMDKindID("tbaa.struct"); 62 assert(TBAAStructID == MD_tbaa_struct && "tbaa.struct kind id drifted"); 63 (void)TBAAStructID; 64 65 // Create the 'invariant.load' metadata kind. 66 unsigned InvariantLdId = getMDKindID("invariant.load"); 67 assert(InvariantLdId == MD_invariant_load && "invariant.load kind id drifted"); 68 (void)InvariantLdId; 69 } 70 LLVMContext::~LLVMContext() { delete pImpl; } 71 72 void LLVMContext::addModule(Module *M) { 73 pImpl->OwnedModules.insert(M); 74 } 75 76 void LLVMContext::removeModule(Module *M) { 77 pImpl->OwnedModules.erase(M); 78 } 79 80 //===----------------------------------------------------------------------===// 81 // Recoverable Backend Errors 82 //===----------------------------------------------------------------------===// 83 84 void LLVMContext:: 85 setInlineAsmDiagnosticHandler(InlineAsmDiagHandlerTy DiagHandler, 86 void *DiagContext) { 87 pImpl->InlineAsmDiagHandler = DiagHandler; 88 pImpl->InlineAsmDiagContext = DiagContext; 89 } 90 91 /// getInlineAsmDiagnosticHandler - Return the diagnostic handler set by 92 /// setInlineAsmDiagnosticHandler. 93 LLVMContext::InlineAsmDiagHandlerTy 94 LLVMContext::getInlineAsmDiagnosticHandler() const { 95 return pImpl->InlineAsmDiagHandler; 96 } 97 98 /// getInlineAsmDiagnosticContext - Return the diagnostic context set by 99 /// setInlineAsmDiagnosticHandler. 100 void *LLVMContext::getInlineAsmDiagnosticContext() const { 101 return pImpl->InlineAsmDiagContext; 102 } 103 104 void LLVMContext::setDiagnosticHandler(DiagnosticHandlerTy DiagnosticHandler, 105 void *DiagnosticContext) { 106 pImpl->DiagnosticHandler = DiagnosticHandler; 107 pImpl->DiagnosticContext = DiagnosticContext; 108 } 109 110 LLVMContext::DiagnosticHandlerTy LLVMContext::getDiagnosticHandler() const { 111 return pImpl->DiagnosticHandler; 112 } 113 114 void *LLVMContext::getDiagnosticContext() const { 115 return pImpl->DiagnosticContext; 116 } 117 118 void LLVMContext::setYieldCallback(YieldCallbackTy Callback, void *OpaqueHandle) 119 { 120 pImpl->YieldCallback = Callback; 121 pImpl->YieldOpaqueHandle = OpaqueHandle; 122 } 123 124 void LLVMContext::yield() { 125 if (pImpl->YieldCallback) 126 pImpl->YieldCallback(this, pImpl->YieldOpaqueHandle); 127 } 128 129 void LLVMContext::emitError(const Twine &ErrorStr) { 130 diagnose(DiagnosticInfoInlineAsm(ErrorStr)); 131 } 132 133 void LLVMContext::emitError(const Instruction *I, const Twine &ErrorStr) { 134 assert (I && "Invalid instruction"); 135 diagnose(DiagnosticInfoInlineAsm(*I, ErrorStr)); 136 } 137 138 void LLVMContext::diagnose(const DiagnosticInfo &DI) { 139 // If there is a report handler, use it. 140 if (pImpl->DiagnosticHandler) { 141 pImpl->DiagnosticHandler(DI, pImpl->DiagnosticContext); 142 return; 143 } 144 145 // Optimization remarks are selective. They need to check whether the regexp 146 // pattern, passed via one of the -pass-remarks* flags, matches the name of 147 // the pass that is emitting the diagnostic. If there is no match, ignore the 148 // diagnostic and return. 149 switch (DI.getKind()) { 150 case llvm::DK_OptimizationRemark: 151 if (!cast<DiagnosticInfoOptimizationRemark>(DI).isEnabled()) 152 return; 153 break; 154 case llvm::DK_OptimizationRemarkMissed: 155 if (!cast<DiagnosticInfoOptimizationRemarkMissed>(DI).isEnabled()) 156 return; 157 break; 158 case llvm::DK_OptimizationRemarkAnalysis: 159 if (!cast<DiagnosticInfoOptimizationRemarkAnalysis>(DI).isEnabled()) 160 return; 161 break; 162 default: 163 break; 164 } 165 166 // Otherwise, print the message with a prefix based on the severity. 167 std::string MsgStorage; 168 raw_string_ostream Stream(MsgStorage); 169 DiagnosticPrinterRawOStream DP(Stream); 170 DI.print(DP); 171 Stream.flush(); 172 switch (DI.getSeverity()) { 173 case DS_Error: 174 errs() << "error: " << MsgStorage << "\n"; 175 exit(1); 176 case DS_Warning: 177 errs() << "warning: " << MsgStorage << "\n"; 178 break; 179 case DS_Remark: 180 errs() << "remark: " << MsgStorage << "\n"; 181 break; 182 case DS_Note: 183 errs() << "note: " << MsgStorage << "\n"; 184 break; 185 } 186 } 187 188 void LLVMContext::emitError(unsigned LocCookie, const Twine &ErrorStr) { 189 diagnose(DiagnosticInfoInlineAsm(LocCookie, ErrorStr)); 190 } 191 192 //===----------------------------------------------------------------------===// 193 // Metadata Kind Uniquing 194 //===----------------------------------------------------------------------===// 195 196 #ifndef NDEBUG 197 /// isValidName - Return true if Name is a valid custom metadata handler name. 198 static bool isValidName(StringRef MDName) { 199 if (MDName.empty()) 200 return false; 201 202 if (!std::isalpha(static_cast<unsigned char>(MDName[0]))) 203 return false; 204 205 for (StringRef::iterator I = MDName.begin() + 1, E = MDName.end(); I != E; 206 ++I) { 207 if (!std::isalnum(static_cast<unsigned char>(*I)) && *I != '_' && 208 *I != '-' && *I != '.') 209 return false; 210 } 211 return true; 212 } 213 #endif 214 215 /// getMDKindID - Return a unique non-zero ID for the specified metadata kind. 216 unsigned LLVMContext::getMDKindID(StringRef Name) const { 217 assert(isValidName(Name) && "Invalid MDNode name"); 218 219 // If this is new, assign it its ID. 220 return 221 pImpl->CustomMDKindNames.GetOrCreateValue( 222 Name, pImpl->CustomMDKindNames.size()).second; 223 } 224 225 /// getHandlerNames - Populate client supplied smallvector using custome 226 /// metadata name and ID. 227 void LLVMContext::getMDKindNames(SmallVectorImpl<StringRef> &Names) const { 228 Names.resize(pImpl->CustomMDKindNames.size()); 229 for (StringMap<unsigned>::const_iterator I = pImpl->CustomMDKindNames.begin(), 230 E = pImpl->CustomMDKindNames.end(); I != E; ++I) 231 Names[I->second] = I->first(); 232 } 233