mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-21 18:29:46 +00:00
This reapplies r197438 and fixes the link-time circular dependency between IR and Support. The fix consists in moving the diagnostic support into IR. The patch adds a new LLVMContext::diagnose that can be used to communicate to the front-end, if any, that something of interest happened. The diagnostics are supported by a new abstraction, the DiagnosticInfo class. The base class contains the following information: - The kind of the report: What this is about. - The severity of the report: How bad this is. This patch also adds 2 classes: - DiagnosticInfoInlineAsm: For inline asm reporting. Basically, this diagnostic will be used to switch to the new diagnostic API for LLVMContext::emitError. - DiagnosticStackSize: For stack size reporting. Comes as a replacement of the hard coded warning in PEI. This patch also features dynamic diagnostic identifiers. In other words plugins can use this infrastructure for their own diagnostics (for more details, see getNextAvailablePluginDiagnosticKind). This patch introduces a new DiagnosticHandlerTy and a new DiagnosticContext in the LLVMContext that should be set by the front-end to be able to map these diagnostics in its own system. http://llvm-reviews.chandlerc.com/D2376 <rdar://problem/15515174> git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@197508 91177308-0d34-0410-b5e6-96231b3b80d8
159 lines
5.1 KiB
C++
159 lines
5.1 KiB
C++
//===-- LLVMContextImpl.cpp - Implement LLVMContextImpl -------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the opaque LLVMContextImpl.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "LLVMContextImpl.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/IR/Attributes.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include <algorithm>
|
|
using namespace llvm;
|
|
|
|
LLVMContextImpl::LLVMContextImpl(LLVMContext &C)
|
|
: TheTrueVal(0), TheFalseVal(0),
|
|
VoidTy(C, Type::VoidTyID),
|
|
LabelTy(C, Type::LabelTyID),
|
|
HalfTy(C, Type::HalfTyID),
|
|
FloatTy(C, Type::FloatTyID),
|
|
DoubleTy(C, Type::DoubleTyID),
|
|
MetadataTy(C, Type::MetadataTyID),
|
|
X86_FP80Ty(C, Type::X86_FP80TyID),
|
|
FP128Ty(C, Type::FP128TyID),
|
|
PPC_FP128Ty(C, Type::PPC_FP128TyID),
|
|
X86_MMXTy(C, Type::X86_MMXTyID),
|
|
Int1Ty(C, 1),
|
|
Int8Ty(C, 8),
|
|
Int16Ty(C, 16),
|
|
Int32Ty(C, 32),
|
|
Int64Ty(C, 64) {
|
|
InlineAsmDiagHandler = 0;
|
|
InlineAsmDiagContext = 0;
|
|
DiagnosticHandler = 0;
|
|
DiagnosticContext = 0;
|
|
NamedStructTypesUniqueID = 0;
|
|
}
|
|
|
|
namespace {
|
|
struct DropReferences {
|
|
// Takes the value_type of a ConstantUniqueMap's internal map, whose 'second'
|
|
// is a Constant*.
|
|
template<typename PairT>
|
|
void operator()(const PairT &P) {
|
|
P.second->dropAllReferences();
|
|
}
|
|
};
|
|
|
|
// Temporary - drops pair.first instead of second.
|
|
struct DropFirst {
|
|
// Takes the value_type of a ConstantUniqueMap's internal map, whose 'second'
|
|
// is a Constant*.
|
|
template<typename PairT>
|
|
void operator()(const PairT &P) {
|
|
P.first->dropAllReferences();
|
|
}
|
|
};
|
|
}
|
|
|
|
LLVMContextImpl::~LLVMContextImpl() {
|
|
// NOTE: We need to delete the contents of OwnedModules, but we have to
|
|
// duplicate it into a temporary vector, because the destructor of Module
|
|
// will try to remove itself from OwnedModules set. This would cause
|
|
// iterator invalidation if we iterated on the set directly.
|
|
std::vector<Module*> Modules(OwnedModules.begin(), OwnedModules.end());
|
|
DeleteContainerPointers(Modules);
|
|
|
|
// Free the constants. This is important to do here to ensure that they are
|
|
// freed before the LeakDetector is torn down.
|
|
std::for_each(ExprConstants.map_begin(), ExprConstants.map_end(),
|
|
DropReferences());
|
|
std::for_each(ArrayConstants.map_begin(), ArrayConstants.map_end(),
|
|
DropFirst());
|
|
std::for_each(StructConstants.map_begin(), StructConstants.map_end(),
|
|
DropFirst());
|
|
std::for_each(VectorConstants.map_begin(), VectorConstants.map_end(),
|
|
DropFirst());
|
|
ExprConstants.freeConstants();
|
|
ArrayConstants.freeConstants();
|
|
StructConstants.freeConstants();
|
|
VectorConstants.freeConstants();
|
|
DeleteContainerSeconds(CAZConstants);
|
|
DeleteContainerSeconds(CPNConstants);
|
|
DeleteContainerSeconds(UVConstants);
|
|
InlineAsms.freeConstants();
|
|
DeleteContainerSeconds(IntConstants);
|
|
DeleteContainerSeconds(FPConstants);
|
|
|
|
for (StringMap<ConstantDataSequential*>::iterator I = CDSConstants.begin(),
|
|
E = CDSConstants.end(); I != E; ++I)
|
|
delete I->second;
|
|
CDSConstants.clear();
|
|
|
|
// Destroy attributes.
|
|
for (FoldingSetIterator<AttributeImpl> I = AttrsSet.begin(),
|
|
E = AttrsSet.end(); I != E; ) {
|
|
FoldingSetIterator<AttributeImpl> Elem = I++;
|
|
delete &*Elem;
|
|
}
|
|
|
|
// Destroy attribute lists.
|
|
for (FoldingSetIterator<AttributeSetImpl> I = AttrsLists.begin(),
|
|
E = AttrsLists.end(); I != E; ) {
|
|
FoldingSetIterator<AttributeSetImpl> Elem = I++;
|
|
delete &*Elem;
|
|
}
|
|
|
|
// Destroy attribute node lists.
|
|
for (FoldingSetIterator<AttributeSetNode> I = AttrsSetNodes.begin(),
|
|
E = AttrsSetNodes.end(); I != E; ) {
|
|
FoldingSetIterator<AttributeSetNode> Elem = I++;
|
|
delete &*Elem;
|
|
}
|
|
|
|
// Destroy MDNodes. ~MDNode can move and remove nodes between the MDNodeSet
|
|
// and the NonUniquedMDNodes sets, so copy the values out first.
|
|
SmallVector<MDNode*, 8> MDNodes;
|
|
MDNodes.reserve(MDNodeSet.size() + NonUniquedMDNodes.size());
|
|
for (FoldingSetIterator<MDNode> I = MDNodeSet.begin(), E = MDNodeSet.end();
|
|
I != E; ++I)
|
|
MDNodes.push_back(&*I);
|
|
MDNodes.append(NonUniquedMDNodes.begin(), NonUniquedMDNodes.end());
|
|
for (SmallVectorImpl<MDNode *>::iterator I = MDNodes.begin(),
|
|
E = MDNodes.end(); I != E; ++I)
|
|
(*I)->destroy();
|
|
assert(MDNodeSet.empty() && NonUniquedMDNodes.empty() &&
|
|
"Destroying all MDNodes didn't empty the Context's sets.");
|
|
|
|
// Destroy MDStrings.
|
|
DeleteContainerSeconds(MDStringCache);
|
|
}
|
|
|
|
// ConstantsContext anchors
|
|
void UnaryConstantExpr::anchor() { }
|
|
|
|
void BinaryConstantExpr::anchor() { }
|
|
|
|
void SelectConstantExpr::anchor() { }
|
|
|
|
void ExtractElementConstantExpr::anchor() { }
|
|
|
|
void InsertElementConstantExpr::anchor() { }
|
|
|
|
void ShuffleVectorConstantExpr::anchor() { }
|
|
|
|
void ExtractValueConstantExpr::anchor() { }
|
|
|
|
void InsertValueConstantExpr::anchor() { }
|
|
|
|
void GetElementPtrConstantExpr::anchor() { }
|
|
|
|
void CompareConstantExpr::anchor() { }
|