RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-24 03:33:20 +01:00
Code Issues Projects Releases Wiki Activity

remove DebugInfoBuilder, it has been subsumed by Analysis/DebugInfo.h

Browse Source 
llvm-svn: 61898
This commit is contained in:
Chris Lattner 2009-01-07 23:25:06 +00:00
parent 6338af14f6
commit 0e3c4e89eb
2 changed files with 0 additions and 425 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

151
include/llvm/Support/DebugInfoBuilder.h
View File

@ -1,151 +0,0 @@
//===-- llvm/Support/DebugInfoBuilder.h - -----------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of the DebugInfoBuilder class, which is
// a helper class used to construct source level debugging information.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_SUPPORT_DEBUGINFOBUILDER_H
#define LLVM_SUPPORT_DEBUGINFOBUILDER_H
#include "llvm/Module.h"
#include <string>
namespace llvm {
class Type;
class IntegerType;
class FloatType;
class StructType;
class PointerType;
class Module;
class GlobalVariable;
class Constant;
namespace sys {
class Path;
}
/// Helper class used to construct source-level debugging information.
///
/// The helper contains a notion of "current context", which is a
/// DWARF descriptor object representing the scope (module, class,
/// function, etc.) that currently encloses the definitions being
/// emitted.
///
/// Initially, you should call setModule() to specify the target
/// module. Descriptors which are generated will be inserted into
/// this module. This also generates the initial set of anchor
/// descriptors, if they have not already been created for the module.
///
/// Next, you should call createCompileUnitDescriptor() to create
/// the descriptor for the current compilation unit. This method
/// sets the current context to the newly created descriptor.
///
/// Once that has been done, you can then create descriptors for
/// global definitions (functions, variables, etc.). You can use
/// setContext() to modify the current context. setContext() returns
/// a reference to the previous context, allowing easy restoration
/// of the previous context.
class DebugInfoBuilder {
private:
Module * module;
PointerType * anyPtrType; // Pointer to empty struct
StructType * anchorType;
GlobalVariable * compileUnit;
GlobalVariable * context;
GlobalVariable * compileUnitAnchor;
GlobalVariable * globalVariableAnchor;
GlobalVariable * subprogramAnchor;
GlobalVariable * compileUnitDescriptor;
// Create an anchor with the specified tag.
GlobalVariable * createAnchor(unsigned anchorTag, const char * anchorName);
// Calculate alignement for primitive types.
unsigned getBasicAlignment(unsigned sizeInBits);
// Calculate the size of the specified LLVM type.
Constant * getSize(const Type * type);
// Calculate the alignment of the specified LLVM type.
Constant * getAlignment(const Type * type);
public:
/// Constructor
DebugInfoBuilder();
/// Return the type defined by llvm.dbg.anchor.type
StructType * getAnchorType() const { return anchorType; }
/// Set the reference to the module where we will insert debugging
/// information. Also defines the debug info types for the module and
/// creates the initial anchors. Also changes the current context to the
// global context for that module.
void setModule(Module * m);
/// Emit a compile unit descriptor. This should be done once for each
/// module before any other debug descriptors are created. This also
/// changes the current context to the global context for the compile unit.
GlobalVariable * createCompileUnitDescriptor(
unsigned langId,
const sys::Path & srcPath,
const std::string & producer);
/// Set a new context, returning the previous context. The context is the
/// debug descriptor representing the current scope (module, function,
/// class, etc.)
GlobalVariable * setContext(GlobalVariable * ctx) {
GlobalVariable * prev = context;
context = ctx;
return prev;
}
/// Emit a subprogram descriptor in the current context.
GlobalVariable * createSubProgramDescriptor(
const std::string & name, // Name of the subprogram
const std::string & qualName, // Fully-qualified name
unsigned line, // Line number
GlobalVariable * typeDesc, // Type descriptor
bool isInternalScoped, // True if internal to module.
bool isDefined); // True if defined in this module.
/// Create a type descriptor for a primitive type.
GlobalVariable * createBasicTypeDescriptor(
std::string & name,
unsigned line,
unsigned sizeInBits,
unsigned alignmentInBits,
unsigned offsetInBits,
unsigned typeEncoding);
/// Create a type descriptor for an integer type
GlobalVariable * createIntegerTypeDescriptor(
std::string & name, const IntegerType * type, bool isSigned);
/// Create a type descriptor for an character type
GlobalVariable * createCharacterTypeDescriptor(
std::string & name, const IntegerType * type, bool isSigned);
/// Create a type descriptor for an floating-point type
GlobalVariable * createFloatTypeDescriptor(std::string & name,
const Type * type);
/// Create a type descriptor for a pointer type.
GlobalVariable * createPointerTypeDescriptor(
std::string & name, // Name of the type
GlobalVariable * referenceType, // Descriptor for what is pointed to
const PointerType * type, // LLVM type of the pointer
unsigned line); // Line number of definition (0 if none)
};
}
#endif

274
lib/VMCore/DebugInfoBuilder.cpp
View File

@ -1,274 +0,0 @@
//===-- llvm/VMCore/DebugInfoBuilder.cpp - ----------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the definition of the DebugInfoBuilder class, which is
// a helper class used to construct source level debugging information.
//
//===----------------------------------------------------------------------===//
#include <llvm/Support/DebugInfoBuilder.h>
#include <llvm/DerivedTypes.h>
#include <llvm/Constants.h>
#include <llvm/GlobalVariable.h>
#include <llvm/Module.h>
#include <llvm/Support/Dwarf.h>
#include <llvm/System/Path.h>
using namespace llvm;
namespace {
//===----------------------------------------------------------------------===//
// Debug version -- copied from MachineModuleInfo (for now), in order to avoid
// creating a dependency on CodeGen. These declarations really should be moved
// to a better place where modules can get at them without being dependent on
// CodeGen.
enum {
LLVMDebugVersion = (6 << 16), // Current version of debug information.
LLVMDebugVersion5 = (5 << 16), // Constant for version 5.
LLVMDebugVersion4 = (4 << 16), // Constant for version 4.
LLVMDebugVersionMask = 0xffff0000 // Mask for version number.
};
const char ANCHOR_TYPE_NAME[] = "llvm.dbg.anchor.type";
const char COMPILE_UNIT_ANCHOR_NAME[] = "llvm.dbg.compile_units";
const char GLOBAL_VAR_ANCHOR_NAME[] = "llvm.dbg.global_variables";
const char SUBPROGRAM_ANCHOR_NAME[] = "llvm.dbg.subprograms";
const char COMPILE_UNIT_TYPE_NAME[] = "llvm.dbg.compile_unit.type";
const char COMPILE_UNIT_NAME[] = "llvm.dbg.compile_unit";
const char SUBPROGRAM_NAME[] = "llvm.dbg.subprogram";
const char BASICTYPE_NAME[] = "llvm.dbg.basictype";
const char DERIVEDTYPE_NAME[] = "llvm.dbg.derivedtype";
} // end anonymous namespace
DebugInfoBuilder::DebugInfoBuilder() {
anyPtrType = PointerType::getUnqual(StructType::get(NULL, NULL));
anchorType = StructType::get(Type::Int32Ty, Type::Int32Ty, NULL);
}
GlobalVariable * DebugInfoBuilder::createAnchor(unsigned anchorTag,
const char * anchorName) {
std::vector<Constant *> values;
values.push_back(ConstantInt::get(Type::Int32Ty, LLVMDebugVersion));
values.push_back(ConstantInt::get(Type::Int32Ty, anchorTag));
return new GlobalVariable(anchorType, true, GlobalValue::LinkOnceLinkage,
ConstantStruct::get(anchorType, values), anchorName, module);
}
// Calculate the size of the specified LLVM type.
Constant * DebugInfoBuilder::getSize(const Type * type) {
Constant * one = ConstantInt::get(Type::Int32Ty, 1);
return ConstantExpr::getPtrToInt(
ConstantExpr::getGetElementPtr(
ConstantPointerNull::get(PointerType::getUnqual(type)),
&one, 1), Type::Int32Ty);
}
Constant * DebugInfoBuilder::getAlignment(const Type * type) {
// Calculates the alignment of T using "sizeof({i8, T}) - sizeof(T)"
return ConstantExpr::getSub(
getSize(StructType::get(Type::Int8Ty, type, NULL)),
getSize(type));
}
void DebugInfoBuilder::setModule(Module * m) {
module = m;
module->addTypeName(ANCHOR_TYPE_NAME, anchorType);
compileUnitAnchor = module->getGlobalVariable(COMPILE_UNIT_ANCHOR_NAME);
if (compileUnitAnchor == NULL) {
compileUnitAnchor =
createAnchor(dwarf::DW_TAG_compile_unit, COMPILE_UNIT_ANCHOR_NAME);
}
globalVariableAnchor = module->getGlobalVariable(GLOBAL_VAR_ANCHOR_NAME);
if (globalVariableAnchor == NULL) {
globalVariableAnchor =
createAnchor(dwarf::DW_TAG_compile_unit, GLOBAL_VAR_ANCHOR_NAME);
}
subprogramAnchor = module->getGlobalVariable(SUBPROGRAM_ANCHOR_NAME);
if (subprogramAnchor == NULL) {
subprogramAnchor =
createAnchor(dwarf::DW_TAG_compile_unit, SUBPROGRAM_ANCHOR_NAME);
}
compileUnit = module->getGlobalVariable(COMPILE_UNIT_NAME);
setContext(compileUnit);
}
GlobalVariable * DebugInfoBuilder::createCompileUnitDescriptor(unsigned langId,
const sys::Path & srcPath, const std::string & producer) {
if (compileUnit == NULL) {
std::vector<Constant *> values;
values.push_back(ConstantInt::get(
Type::Int32Ty, LLVMDebugVersion + dwarf::DW_TAG_compile_unit));
values.push_back(
ConstantExpr::getBitCast(compileUnitAnchor, anyPtrType));
values.push_back(ConstantInt::get(Type::Int32Ty, langId));
values.push_back(ConstantArray::get(srcPath.getLast()));
values.push_back(ConstantArray::get(srcPath.getDirname() + "/"));
values.push_back(ConstantArray::get(producer));
Constant * structVal = ConstantStruct::get(values, false);
compileUnit = new GlobalVariable(structVal->getType(), true,
GlobalValue::InternalLinkage, structVal, COMPILE_UNIT_NAME, module);
}
setContext(compileUnit);
return compileUnit;
}
GlobalVariable * DebugInfoBuilder::createSubProgramDescriptor(
const std::string & name,
const std::string & qualifiedName,
unsigned line,
GlobalVariable * typeDesc,
bool isInternal,
bool isDefined) {
assert(compileUnit != NULL);
assert(subprogramAnchor != NULL);
std::vector<Constant *> values;
values.push_back(ConstantInt::get(
Type::Int32Ty, LLVMDebugVersion + dwarf::DW_TAG_subprogram));
values.push_back(ConstantExpr::getBitCast(subprogramAnchor, anyPtrType));
values.push_back(ConstantExpr::getBitCast(context, anyPtrType));
values.push_back(ConstantArray::get(name));
values.push_back(ConstantArray::get(qualifiedName));
values.push_back(ConstantArray::get(qualifiedName));
values.push_back(ConstantExpr::getBitCast(compileUnit, anyPtrType));
values.push_back(ConstantInt::get(Type::Int32Ty, line));
values.push_back(typeDesc ?
ConstantExpr::getBitCast(typeDesc, anyPtrType) :
ConstantPointerNull::get(anyPtrType));
values.push_back(ConstantInt::get(Type::Int1Ty, isInternal));
values.push_back(ConstantInt::get(Type::Int1Ty, isDefined));
Constant * structVal = ConstantStruct::get(values, false);
return new GlobalVariable(structVal->getType(), true,
GlobalValue::InternalLinkage, structVal, SUBPROGRAM_NAME, module);
}
GlobalVariable * DebugInfoBuilder::createBasicTypeDescriptor(
std::string & name,
unsigned line,
unsigned sizeInBits,
unsigned alignmentInBits,
unsigned offsetInBits,
unsigned typeEncoding) {
std::vector<Constant *> values;
values.push_back(ConstantInt::get(
Type::Int32Ty, LLVMDebugVersion + dwarf::DW_TAG_base_type));
values.push_back(ConstantExpr::getBitCast(context, anyPtrType));
values.push_back(ConstantArray::get(name));
values.push_back(ConstantExpr::getBitCast(compileUnit, anyPtrType));
values.push_back(ConstantInt::get(Type::Int32Ty, line));
values.push_back(ConstantInt::get(Type::Int32Ty, sizeInBits));
values.push_back(ConstantInt::get(Type::Int32Ty, alignmentInBits));
values.push_back(ConstantInt::get(Type::Int32Ty, offsetInBits));
values.push_back(ConstantInt::get(Type::Int32Ty, typeEncoding));
Constant * structVal = ConstantStruct::get(values, false);
return new GlobalVariable(structVal->getType(), true,
GlobalValue::InternalLinkage, structVal, BASICTYPE_NAME, module);
}
GlobalVariable * DebugInfoBuilder::createIntegerTypeDescriptor(
std::string & name, const IntegerType * type, bool isSigned) {
std::vector<Constant *> values;
values.push_back(ConstantInt::get(
Type::Int32Ty, LLVMDebugVersion + dwarf::DW_TAG_base_type));
values.push_back(ConstantPointerNull::get(anyPtrType));
values.push_back(ConstantArray::get(name));
values.push_back(ConstantPointerNull::get(anyPtrType));
values.push_back(ConstantInt::get(Type::Int32Ty, 0));
values.push_back(ConstantInt::get(Type::Int32Ty, type->getBitWidth()));
values.push_back(getAlignment(type));
values.push_back(ConstantInt::get(Type::Int32Ty, 0));
values.push_back(ConstantInt::get(Type::Int32Ty,
isSigned ? dwarf::DW_ATE_signed_char : dwarf::DW_ATE_unsigned_char));
Constant * structVal = ConstantStruct::get(values, false);
return new GlobalVariable(structVal->getType(), true,
GlobalValue::InternalLinkage, structVal, BASICTYPE_NAME, module);
}
GlobalVariable * DebugInfoBuilder::createCharacterTypeDescriptor(
std::string & name, const IntegerType * type, bool isSigned) {
std::vector<Constant *> values;
values.push_back(ConstantInt::get(
Type::Int32Ty, LLVMDebugVersion + dwarf::DW_TAG_base_type));
values.push_back(ConstantPointerNull::get(anyPtrType));
values.push_back(ConstantArray::get(name));
values.push_back(ConstantPointerNull::get(anyPtrType));
values.push_back(ConstantInt::get(Type::Int32Ty, 0));
values.push_back(ConstantInt::get(Type::Int32Ty, type->getBitWidth()));
values.push_back(getAlignment(type));
values.push_back(ConstantInt::get(Type::Int32Ty, 0/*offsetInBits*/));
values.push_back(ConstantInt::get(Type::Int32Ty,
isSigned ? dwarf::DW_ATE_signed_char : dwarf::DW_ATE_unsigned_char));
Constant * structVal = ConstantStruct::get(values, false);
return new GlobalVariable(structVal->getType(), true,
GlobalValue::InternalLinkage, structVal, BASICTYPE_NAME, module);
}
GlobalVariable * DebugInfoBuilder::createFloatTypeDescriptor(
std::string & name, const Type * type) {
std::vector<Constant *> values;
values.push_back(ConstantInt::get(
Type::Int32Ty, LLVMDebugVersion + dwarf::DW_TAG_base_type));
values.push_back(ConstantPointerNull::get(anyPtrType));
values.push_back(ConstantArray::get(name));
values.push_back(ConstantPointerNull::get(anyPtrType));
values.push_back(ConstantInt::get(Type::Int32Ty, 0));
values.push_back(getSize(type));
values.push_back(getAlignment(type));
values.push_back(ConstantInt::get(Type::Int32Ty, 0/*offsetInBits*/));
values.push_back(ConstantInt::get(Type::Int32Ty, dwarf::DW_ATE_float));
Constant * structVal = ConstantStruct::get(values, false);
return new GlobalVariable(structVal->getType(), true,
GlobalValue::InternalLinkage, structVal, BASICTYPE_NAME, module);
}
GlobalVariable * DebugInfoBuilder::createPointerTypeDescriptor(
std::string & name,
GlobalVariable * referenceType,
const PointerType * type,
unsigned line) {
std::vector<Constant *> values;
values.push_back(ConstantInt::get(
Type::Int32Ty, dwarf::DW_TAG_pointer_type + LLVMDebugVersion));
values.push_back(
context ? ConstantExpr::getBitCast(context, anyPtrType) : NULL);
values.push_back(ConstantArray::get(name));
values.push_back(
compileUnit ? ConstantExpr::getBitCast(compileUnit, anyPtrType) : NULL);
values.push_back(ConstantInt::get(Type::Int32Ty, line));
values.push_back(getSize(type));
values.push_back(getAlignment(type));
values.push_back(ConstantInt::get(Type::Int32Ty, 0));
values.push_back(referenceType);
Constant * structVal = ConstantStruct::get(values, false);
return new GlobalVariable(structVal->getType(), true,
GlobalValue::InternalLinkage, structVal, DERIVEDTYPE_NAME, module);
}