X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FIR%2FLLVMContext.cpp;h=d4ba83dfa622c1483fd2f92dcb824c9e88b0e38f;hb=049ffbbdf2a43d5529cb56b6bb696d20d28ff217;hp=fc6392ba78c7b65e98bf144299a1b56cc49270ac;hpb=c2c50cdcdc19a1bca993c06d13d8cdca87083ce4;p=oota-llvm.git diff --git a/lib/IR/LLVMContext.cpp b/lib/IR/LLVMContext.cpp index fc6392ba78c..d4ba83dfa62 100644 --- a/lib/IR/LLVMContext.cpp +++ b/lib/IR/LLVMContext.cpp @@ -12,11 +12,14 @@ // //===----------------------------------------------------------------------===// -#include "llvm/LLVMContext.h" +#include "llvm/IR/LLVMContext.h" #include "LLVMContextImpl.h" -#include "llvm/Constants.h" -#include "llvm/Instruction.h" -#include "llvm/Metadata.h" +#include "llvm/IR/Constants.h" +#include "llvm/IR/DebugLoc.h" +#include "llvm/IR/DiagnosticInfo.h" +#include "llvm/IR/DiagnosticPrinter.h" +#include "llvm/IR/Instruction.h" +#include "llvm/IR/Metadata.h" #include "llvm/Support/ManagedStatic.h" #include "llvm/Support/SourceMgr.h" #include @@ -58,6 +61,21 @@ LLVMContext::LLVMContext() : pImpl(new LLVMContextImpl(*this)) { unsigned TBAAStructID = getMDKindID("tbaa.struct"); assert(TBAAStructID == MD_tbaa_struct && "tbaa.struct kind id drifted"); (void)TBAAStructID; + + // Create the 'invariant.load' metadata kind. + unsigned InvariantLdId = getMDKindID("invariant.load"); + assert(InvariantLdId == MD_invariant_load && "invariant.load kind id drifted"); + (void)InvariantLdId; + + // Create the 'alias.scope' metadata kind. + unsigned AliasScopeID = getMDKindID("alias.scope"); + assert(AliasScopeID == MD_alias_scope && "alias.scope kind id drifted"); + (void)AliasScopeID; + + // Create the 'noalias' metadata kind. + unsigned NoAliasID = getMDKindID("noalias"); + assert(NoAliasID == MD_noalias && "noalias kind id drifted"); + (void)NoAliasID; } LLVMContext::~LLVMContext() { delete pImpl; } @@ -73,76 +91,112 @@ void LLVMContext::removeModule(Module *M) { // Recoverable Backend Errors //===----------------------------------------------------------------------===// -void LLVMContext::setDiagnosticHandler(DiagHandlerTy DiagHandler, - void *DiagContext) { - pImpl->DiagHandler = DiagHandler; - pImpl->DiagContext = DiagContext; +void LLVMContext:: +setInlineAsmDiagnosticHandler(InlineAsmDiagHandlerTy DiagHandler, + void *DiagContext) { + pImpl->InlineAsmDiagHandler = DiagHandler; + pImpl->InlineAsmDiagContext = DiagContext; } -/// getDiagnosticHandler - Return the diagnostic handler set by -/// setDiagnosticHandler. -LLVMContext::DiagHandlerTy LLVMContext::getDiagnosticHandler() const { - return pImpl->DiagHandler; +/// getInlineAsmDiagnosticHandler - Return the diagnostic handler set by +/// setInlineAsmDiagnosticHandler. +LLVMContext::InlineAsmDiagHandlerTy +LLVMContext::getInlineAsmDiagnosticHandler() const { + return pImpl->InlineAsmDiagHandler; } -/// getDiagnosticContext - Return the diagnostic context set by -/// setDiagnosticHandler. -void *LLVMContext::getDiagnosticContext() const { - return pImpl->DiagContext; +/// getInlineAsmDiagnosticContext - Return the diagnostic context set by +/// setInlineAsmDiagnosticHandler. +void *LLVMContext::getInlineAsmDiagnosticContext() const { + return pImpl->InlineAsmDiagContext; } -void LLVMContext::emitError(const Twine &ErrorStr) { - emitError(0U, ErrorStr); +void LLVMContext::setDiagnosticHandler(DiagnosticHandlerTy DiagnosticHandler, + void *DiagnosticContext) { + pImpl->DiagnosticHandler = DiagnosticHandler; + pImpl->DiagnosticContext = DiagnosticContext; } -void LLVMContext::emitWarning(const Twine &ErrorStr) { - emitWarning(0U, ErrorStr); +LLVMContext::DiagnosticHandlerTy LLVMContext::getDiagnosticHandler() const { + return pImpl->DiagnosticHandler; } -static unsigned getSrcLocation(const Instruction *I) { - unsigned LocCookie = 0; - if (const MDNode *SrcLoc = I->getMetadata("srcloc")) { - if (SrcLoc->getNumOperands() != 0) - if (const ConstantInt *CI = dyn_cast(SrcLoc->getOperand(0))) - LocCookie = CI->getZExtValue(); - } - return LocCookie; +void *LLVMContext::getDiagnosticContext() const { + return pImpl->DiagnosticContext; } -void LLVMContext::emitError(const Instruction *I, const Twine &ErrorStr) { - unsigned LocCookie = getSrcLocation(I); - return emitError(LocCookie, ErrorStr); +void LLVMContext::setYieldCallback(YieldCallbackTy Callback, void *OpaqueHandle) +{ + pImpl->YieldCallback = Callback; + pImpl->YieldOpaqueHandle = OpaqueHandle; } -void LLVMContext::emitWarning(const Instruction *I, const Twine &ErrorStr) { - unsigned LocCookie = getSrcLocation(I); - return emitWarning(LocCookie, ErrorStr); +void LLVMContext::yield() { + if (pImpl->YieldCallback) + pImpl->YieldCallback(this, pImpl->YieldOpaqueHandle); } -void LLVMContext::emitError(unsigned LocCookie, const Twine &ErrorStr) { - // If there is no error handler installed, just print the error and exit. - if (pImpl->DiagHandler == 0) { - errs() << "error: " << ErrorStr << "\n"; - exit(1); - } - - // If we do have an error handler, we can report the error and keep going. - SMDiagnostic Diag("", SourceMgr::DK_Error, ErrorStr.str()); +void LLVMContext::emitError(const Twine &ErrorStr) { + diagnose(DiagnosticInfoInlineAsm(ErrorStr)); +} - pImpl->DiagHandler(Diag, pImpl->DiagContext, LocCookie); +void LLVMContext::emitError(const Instruction *I, const Twine &ErrorStr) { + assert (I && "Invalid instruction"); + diagnose(DiagnosticInfoInlineAsm(*I, ErrorStr)); } -void LLVMContext::emitWarning(unsigned LocCookie, const Twine &ErrorStr) { - // If there is no handler installed, just print the warning. - if (pImpl->DiagHandler == 0) { - errs() << "warning: " << ErrorStr << "\n"; +void LLVMContext::diagnose(const DiagnosticInfo &DI) { + // If there is a report handler, use it. + if (pImpl->DiagnosticHandler) { + pImpl->DiagnosticHandler(DI, pImpl->DiagnosticContext); return; } - // If we do have a handler, we can report the warning. - SMDiagnostic Diag("", SourceMgr::DK_Warning, ErrorStr.str()); + // Optimization remarks are selective. They need to check whether the regexp + // pattern, passed via one of the -pass-remarks* flags, matches the name of + // the pass that is emitting the diagnostic. If there is no match, ignore the + // diagnostic and return. + switch (DI.getKind()) { + case llvm::DK_OptimizationRemark: + if (!cast(DI).isEnabled()) + return; + break; + case llvm::DK_OptimizationRemarkMissed: + if (!cast(DI).isEnabled()) + return; + break; + case llvm::DK_OptimizationRemarkAnalysis: + if (!cast(DI).isEnabled()) + return; + break; + default: + break; + } + + // Otherwise, print the message with a prefix based on the severity. + std::string MsgStorage; + raw_string_ostream Stream(MsgStorage); + DiagnosticPrinterRawOStream DP(Stream); + DI.print(DP); + Stream.flush(); + switch (DI.getSeverity()) { + case DS_Error: + errs() << "error: " << MsgStorage << "\n"; + exit(1); + case DS_Warning: + errs() << "warning: " << MsgStorage << "\n"; + break; + case DS_Remark: + errs() << "remark: " << MsgStorage << "\n"; + break; + case DS_Note: + errs() << "note: " << MsgStorage << "\n"; + break; + } +} - pImpl->DiagHandler(Diag, pImpl->DiagContext, LocCookie); +void LLVMContext::emitError(unsigned LocCookie, const Twine &ErrorStr) { + diagnose(DiagnosticInfoInlineAsm(LocCookie, ErrorStr)); } //===----------------------------------------------------------------------===// @@ -155,12 +209,13 @@ static bool isValidName(StringRef MDName) { if (MDName.empty()) return false; - if (!std::isalpha(MDName[0])) + if (!std::isalpha(static_cast(MDName[0]))) return false; for (StringRef::iterator I = MDName.begin() + 1, E = MDName.end(); I != E; ++I) { - if (!std::isalnum(*I) && *I != '_' && *I != '-' && *I != '.') + if (!std::isalnum(static_cast(*I)) && *I != '_' && + *I != '-' && *I != '.') return false; } return true;