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/ADT/SmallVector.h" 18 #include "llvm/ADT/StringMap.h" 19 #include "llvm/ADT/StringRef.h" 20 #include "llvm/ADT/Twine.h" 21 #include "llvm/IR/DiagnosticInfo.h" 22 #include "llvm/IR/DiagnosticPrinter.h" 23 #include "llvm/IR/Metadata.h" 24 #include "llvm/IR/Module.h" 25 #include "llvm/Support/Casting.h" 26 #include "llvm/Support/ErrorHandling.h" 27 #include "llvm/Support/raw_ostream.h" 28 #include <cassert> 29 #include <cstdlib> 30 #include <string> 31 #include <utility> 32 33 using namespace llvm; 34 35 LLVMContext::LLVMContext() : pImpl(new LLVMContextImpl(*this)) { 36 // Create the fixed metadata kinds. This is done in the same order as the 37 // MD_* enum values so that they correspond. 38 std::pair<unsigned, StringRef> MDKinds[] = { 39 {MD_dbg, "dbg"}, 40 {MD_tbaa, "tbaa"}, 41 {MD_prof, "prof"}, 42 {MD_fpmath, "fpmath"}, 43 {MD_range, "range"}, 44 {MD_tbaa_struct, "tbaa.struct"}, 45 {MD_invariant_load, "invariant.load"}, 46 {MD_alias_scope, "alias.scope"}, 47 {MD_noalias, "noalias"}, 48 {MD_nontemporal, "nontemporal"}, 49 {MD_mem_parallel_loop_access, "llvm.mem.parallel_loop_access"}, 50 {MD_nonnull, "nonnull"}, 51 {MD_dereferenceable, "dereferenceable"}, 52 {MD_dereferenceable_or_null, "dereferenceable_or_null"}, 53 {MD_make_implicit, "make.implicit"}, 54 {MD_unpredictable, "unpredictable"}, 55 {MD_invariant_group, "invariant.group"}, 56 {MD_align, "align"}, 57 {MD_loop, "llvm.loop"}, 58 {MD_type, "type"}, 59 {MD_section_prefix, "section_prefix"}, 60 {MD_absolute_symbol, "absolute_symbol"}, 61 {MD_associated, "associated"}, 62 {MD_callees, "callees"}, 63 {MD_irr_loop, "irr_loop"}, 64 }; 65 66 for (auto &MDKind : MDKinds) { 67 unsigned ID = getMDKindID(MDKind.second); 68 assert(ID == MDKind.first && "metadata kind id drifted"); 69 (void)ID; 70 } 71 72 auto *DeoptEntry = pImpl->getOrInsertBundleTag("deopt"); 73 assert(DeoptEntry->second == LLVMContext::OB_deopt && 74 "deopt operand bundle id drifted!"); 75 (void)DeoptEntry; 76 77 auto *FuncletEntry = pImpl->getOrInsertBundleTag("funclet"); 78 assert(FuncletEntry->second == LLVMContext::OB_funclet && 79 "funclet operand bundle id drifted!"); 80 (void)FuncletEntry; 81 82 auto *GCTransitionEntry = pImpl->getOrInsertBundleTag("gc-transition"); 83 assert(GCTransitionEntry->second == LLVMContext::OB_gc_transition && 84 "gc-transition operand bundle id drifted!"); 85 (void)GCTransitionEntry; 86 87 SyncScope::ID SingleThreadSSID = 88 pImpl->getOrInsertSyncScopeID("singlethread"); 89 assert(SingleThreadSSID == SyncScope::SingleThread && 90 "singlethread synchronization scope ID drifted!"); 91 (void)SingleThreadSSID; 92 93 SyncScope::ID SystemSSID = 94 pImpl->getOrInsertSyncScopeID(""); 95 assert(SystemSSID == SyncScope::System && 96 "system synchronization scope ID drifted!"); 97 (void)SystemSSID; 98 } 99 100 LLVMContext::~LLVMContext() { delete pImpl; } 101 102 void LLVMContext::addModule(Module *M) { 103 pImpl->OwnedModules.insert(M); 104 } 105 106 void LLVMContext::removeModule(Module *M) { 107 pImpl->OwnedModules.erase(M); 108 } 109 110 //===----------------------------------------------------------------------===// 111 // Recoverable Backend Errors 112 //===----------------------------------------------------------------------===// 113 114 void LLVMContext:: 115 setInlineAsmDiagnosticHandler(InlineAsmDiagHandlerTy DiagHandler, 116 void *DiagContext) { 117 pImpl->InlineAsmDiagHandler = DiagHandler; 118 pImpl->InlineAsmDiagContext = DiagContext; 119 } 120 121 /// getInlineAsmDiagnosticHandler - Return the diagnostic handler set by 122 /// setInlineAsmDiagnosticHandler. 123 LLVMContext::InlineAsmDiagHandlerTy 124 LLVMContext::getInlineAsmDiagnosticHandler() const { 125 return pImpl->InlineAsmDiagHandler; 126 } 127 128 /// getInlineAsmDiagnosticContext - Return the diagnostic context set by 129 /// setInlineAsmDiagnosticHandler. 130 void *LLVMContext::getInlineAsmDiagnosticContext() const { 131 return pImpl->InlineAsmDiagContext; 132 } 133 134 void LLVMContext::setDiagnosticHandlerCallBack( 135 DiagnosticHandler::DiagnosticHandlerTy DiagnosticHandler, 136 void *DiagnosticContext, bool RespectFilters) { 137 pImpl->DiagHandler->DiagHandlerCallback = DiagnosticHandler; 138 pImpl->DiagHandler->DiagnosticContext = DiagnosticContext; 139 pImpl->RespectDiagnosticFilters = RespectFilters; 140 } 141 142 void LLVMContext::setDiagnosticHandler(std::unique_ptr<DiagnosticHandler> &&DH, 143 bool RespectFilters) { 144 pImpl->DiagHandler = std::move(DH); 145 pImpl->RespectDiagnosticFilters = RespectFilters; 146 } 147 148 void LLVMContext::setDiagnosticsHotnessRequested(bool Requested) { 149 pImpl->DiagnosticsHotnessRequested = Requested; 150 } 151 bool LLVMContext::getDiagnosticsHotnessRequested() const { 152 return pImpl->DiagnosticsHotnessRequested; 153 } 154 155 void LLVMContext::setDiagnosticsHotnessThreshold(uint64_t Threshold) { 156 pImpl->DiagnosticsHotnessThreshold = Threshold; 157 } 158 uint64_t LLVMContext::getDiagnosticsHotnessThreshold() const { 159 return pImpl->DiagnosticsHotnessThreshold; 160 } 161 162 yaml::Output *LLVMContext::getDiagnosticsOutputFile() { 163 return pImpl->DiagnosticsOutputFile.get(); 164 } 165 166 void LLVMContext::setDiagnosticsOutputFile(std::unique_ptr<yaml::Output> F) { 167 pImpl->DiagnosticsOutputFile = std::move(F); 168 } 169 170 DiagnosticHandler::DiagnosticHandlerTy 171 LLVMContext::getDiagnosticHandlerCallBack() const { 172 return pImpl->DiagHandler->DiagHandlerCallback; 173 } 174 175 void *LLVMContext::getDiagnosticContext() const { 176 return pImpl->DiagHandler->DiagnosticContext; 177 } 178 179 void LLVMContext::setYieldCallback(YieldCallbackTy Callback, void *OpaqueHandle) 180 { 181 pImpl->YieldCallback = Callback; 182 pImpl->YieldOpaqueHandle = OpaqueHandle; 183 } 184 185 void LLVMContext::yield() { 186 if (pImpl->YieldCallback) 187 pImpl->YieldCallback(this, pImpl->YieldOpaqueHandle); 188 } 189 190 void LLVMContext::emitError(const Twine &ErrorStr) { 191 diagnose(DiagnosticInfoInlineAsm(ErrorStr)); 192 } 193 194 void LLVMContext::emitError(const Instruction *I, const Twine &ErrorStr) { 195 assert (I && "Invalid instruction"); 196 diagnose(DiagnosticInfoInlineAsm(*I, ErrorStr)); 197 } 198 199 static bool isDiagnosticEnabled(const DiagnosticInfo &DI) { 200 // Optimization remarks are selective. They need to check whether the regexp 201 // pattern, passed via one of the -pass-remarks* flags, matches the name of 202 // the pass that is emitting the diagnostic. If there is no match, ignore the 203 // diagnostic and return. 204 // 205 // Also noisy remarks are only enabled if we have hotness information to sort 206 // them. 207 if (auto *Remark = dyn_cast<DiagnosticInfoOptimizationBase>(&DI)) 208 return Remark->isEnabled() && 209 (!Remark->isVerbose() || Remark->getHotness()); 210 211 return true; 212 } 213 214 const char * 215 LLVMContext::getDiagnosticMessagePrefix(DiagnosticSeverity Severity) { 216 switch (Severity) { 217 case DS_Error: 218 return "error"; 219 case DS_Warning: 220 return "warning"; 221 case DS_Remark: 222 return "remark"; 223 case DS_Note: 224 return "note"; 225 } 226 llvm_unreachable("Unknown DiagnosticSeverity"); 227 } 228 229 void LLVMContext::diagnose(const DiagnosticInfo &DI) { 230 if (auto *OptDiagBase = dyn_cast<DiagnosticInfoOptimizationBase>(&DI)) { 231 yaml::Output *Out = getDiagnosticsOutputFile(); 232 if (Out) { 233 // For remarks the << operator takes a reference to a pointer. 234 auto *P = const_cast<DiagnosticInfoOptimizationBase *>(OptDiagBase); 235 *Out << P; 236 } 237 } 238 // If there is a report handler, use it. 239 if (pImpl->DiagHandler && 240 (!pImpl->RespectDiagnosticFilters || isDiagnosticEnabled(DI)) && 241 pImpl->DiagHandler->handleDiagnostics(DI)) 242 return; 243 244 if (!isDiagnosticEnabled(DI)) 245 return; 246 247 // Otherwise, print the message with a prefix based on the severity. 248 DiagnosticPrinterRawOStream DP(errs()); 249 errs() << getDiagnosticMessagePrefix(DI.getSeverity()) << ": "; 250 DI.print(DP); 251 errs() << "\n"; 252 if (DI.getSeverity() == DS_Error) 253 exit(1); 254 } 255 256 void LLVMContext::emitError(unsigned LocCookie, const Twine &ErrorStr) { 257 diagnose(DiagnosticInfoInlineAsm(LocCookie, ErrorStr)); 258 } 259 260 //===----------------------------------------------------------------------===// 261 // Metadata Kind Uniquing 262 //===----------------------------------------------------------------------===// 263 264 /// Return a unique non-zero ID for the specified metadata kind. 265 unsigned LLVMContext::getMDKindID(StringRef Name) const { 266 // If this is new, assign it its ID. 267 return pImpl->CustomMDKindNames.insert( 268 std::make_pair( 269 Name, pImpl->CustomMDKindNames.size())) 270 .first->second; 271 } 272 273 /// getHandlerNames - Populate client-supplied smallvector using custom 274 /// metadata name and ID. 275 void LLVMContext::getMDKindNames(SmallVectorImpl<StringRef> &Names) const { 276 Names.resize(pImpl->CustomMDKindNames.size()); 277 for (StringMap<unsigned>::const_iterator I = pImpl->CustomMDKindNames.begin(), 278 E = pImpl->CustomMDKindNames.end(); I != E; ++I) 279 Names[I->second] = I->first(); 280 } 281 282 void LLVMContext::getOperandBundleTags(SmallVectorImpl<StringRef> &Tags) const { 283 pImpl->getOperandBundleTags(Tags); 284 } 285 286 uint32_t LLVMContext::getOperandBundleTagID(StringRef Tag) const { 287 return pImpl->getOperandBundleTagID(Tag); 288 } 289 290 SyncScope::ID LLVMContext::getOrInsertSyncScopeID(StringRef SSN) { 291 return pImpl->getOrInsertSyncScopeID(SSN); 292 } 293 294 void LLVMContext::getSyncScopeNames(SmallVectorImpl<StringRef> &SSNs) const { 295 pImpl->getSyncScopeNames(SSNs); 296 } 297 298 void LLVMContext::setGC(const Function &Fn, std::string GCName) { 299 auto It = pImpl->GCNames.find(&Fn); 300 301 if (It == pImpl->GCNames.end()) { 302 pImpl->GCNames.insert(std::make_pair(&Fn, std::move(GCName))); 303 return; 304 } 305 It->second = std::move(GCName); 306 } 307 308 const std::string &LLVMContext::getGC(const Function &Fn) { 309 return pImpl->GCNames[&Fn]; 310 } 311 312 void LLVMContext::deleteGC(const Function &Fn) { 313 pImpl->GCNames.erase(&Fn); 314 } 315 316 bool LLVMContext::shouldDiscardValueNames() const { 317 return pImpl->DiscardValueNames; 318 } 319 320 bool LLVMContext::isODRUniquingDebugTypes() const { return !!pImpl->DITypeMap; } 321 322 void LLVMContext::enableDebugTypeODRUniquing() { 323 if (pImpl->DITypeMap) 324 return; 325 326 pImpl->DITypeMap.emplace(); 327 } 328 329 void LLVMContext::disableDebugTypeODRUniquing() { pImpl->DITypeMap.reset(); } 330 331 void LLVMContext::setDiscardValueNames(bool Discard) { 332 pImpl->DiscardValueNames = Discard; 333 } 334 335 OptPassGate &LLVMContext::getOptPassGate() const { 336 return pImpl->getOptPassGate(); 337 } 338 339 void LLVMContext::setOptPassGate(OptPassGate& OPG) { 340 pImpl->setOptPassGate(OPG); 341 } 342 343 const DiagnosticHandler *LLVMContext::getDiagHandlerPtr() const { 344 return pImpl->DiagHandler.get(); 345 } 346 347 std::unique_ptr<DiagnosticHandler> LLVMContext::getDiagnosticHandler() { 348 return std::move(pImpl->DiagHandler); 349 } 350