mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-08 03:29:41 +00:00
3fc7e532aa
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@72781 91177308-0d34-0410-b5e6-96231b3b80d8
293 lines
9.4 KiB
C++
293 lines
9.4 KiB
C++
//===-- PIC16DebugInfo.cpp - Implementation for PIC16 Debug Information ======//
|
|
//
|
|
// 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 helper functions for representing debug information.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "PIC16.h"
|
|
#include "PIC16DebugInfo.h"
|
|
#include "llvm/GlobalVariable.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
using namespace llvm;
|
|
|
|
PIC16DbgInfo::~PIC16DbgInfo() {
|
|
for(std::map<std::string, DISubprogram *>::iterator i = FunctNameMap.begin();
|
|
i!=FunctNameMap.end(); i++)
|
|
delete i->second;
|
|
FunctNameMap.clear();
|
|
}
|
|
|
|
void PIC16DbgInfo::PopulateDebugInfo(DIType Ty, unsigned short &TypeNo,
|
|
bool &HasAux, int Aux[],
|
|
std::string &TypeName) {
|
|
if (Ty.isBasicType(Ty.getTag())) {
|
|
std::string Name = "";
|
|
Ty.getName(Name);
|
|
unsigned short BaseTy = GetTypeDebugNumber(Name);
|
|
TypeNo = TypeNo << PIC16Dbg::S_BASIC;
|
|
TypeNo = TypeNo | (0xffff & BaseTy);
|
|
}
|
|
else if (Ty.isDerivedType(Ty.getTag())) {
|
|
switch(Ty.getTag())
|
|
{
|
|
case dwarf::DW_TAG_pointer_type:
|
|
TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
|
|
TypeNo = TypeNo | PIC16Dbg::DT_PTR;
|
|
break;
|
|
default:
|
|
TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
|
|
}
|
|
DIType BaseType = DIDerivedType(Ty.getGV()).getTypeDerivedFrom();
|
|
PopulateDebugInfo(BaseType, TypeNo, HasAux, Aux, TypeName);
|
|
}
|
|
else if (Ty.isCompositeType(Ty.getTag())) {
|
|
switch (Ty.getTag()) {
|
|
case dwarf::DW_TAG_array_type: {
|
|
DICompositeType CTy = DICompositeType(Ty.getGV());
|
|
DIArray Elements = CTy.getTypeArray();
|
|
unsigned short size = 1;
|
|
unsigned short Dimension[4]={0,0,0,0};
|
|
for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
|
|
DIDescriptor Element = Elements.getElement(i);
|
|
if (Element.getTag() == dwarf::DW_TAG_subrange_type) {
|
|
TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
|
|
TypeNo = TypeNo | PIC16Dbg::DT_ARY;
|
|
DISubrange SubRange = DISubrange(Element.getGV());
|
|
Dimension[i] = SubRange.getHi() - SubRange.getLo() + 1;
|
|
// Each dimension is represented by 2 bytes starting at byte 9.
|
|
Aux[8+i*2+0] = Dimension[i];
|
|
Aux[8+i*2+1] = Dimension[i] >> 8;
|
|
size = size * Dimension[i];
|
|
}
|
|
}
|
|
HasAux = true;
|
|
// In auxillary entry for array, 7th and 8th byte represent array size.
|
|
Aux[6] = size;
|
|
Aux[7] = size >> 8;
|
|
DIType BaseType = CTy.getTypeDerivedFrom();
|
|
PopulateDebugInfo(BaseType, TypeNo, HasAux, Aux, TypeName);
|
|
|
|
break;
|
|
}
|
|
case dwarf:: DW_TAG_union_type:
|
|
case dwarf::DW_TAG_structure_type: {
|
|
DICompositeType CTy = DICompositeType(Ty.getGV());
|
|
TypeNo = TypeNo << PIC16Dbg::S_BASIC;
|
|
if (Ty.getTag() == dwarf::DW_TAG_structure_type)
|
|
TypeNo = TypeNo | PIC16Dbg::T_STRUCT;
|
|
else
|
|
TypeNo = TypeNo | PIC16Dbg::T_UNION;
|
|
CTy.getName(TypeName);
|
|
unsigned size = CTy.getSizeInBits()/8;
|
|
// 7th and 8th byte represent size.
|
|
HasAux = true;
|
|
Aux[6] = size;
|
|
Aux[7] = size >> 8;
|
|
break;
|
|
}
|
|
case dwarf::DW_TAG_enumeration_type: {
|
|
TypeNo = TypeNo << PIC16Dbg::S_BASIC;
|
|
TypeNo = TypeNo | PIC16Dbg::T_ENUM;
|
|
break;
|
|
}
|
|
default:
|
|
TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
|
|
}
|
|
}
|
|
else {
|
|
TypeNo = PIC16Dbg::T_NULL;
|
|
HasAux = false;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
unsigned PIC16DbgInfo::GetTypeDebugNumber(std::string &type) {
|
|
if (type == "char")
|
|
return PIC16Dbg::T_CHAR;
|
|
else if (type == "short")
|
|
return PIC16Dbg::T_SHORT;
|
|
else if (type == "int")
|
|
return PIC16Dbg::T_INT;
|
|
else if (type == "long")
|
|
return PIC16Dbg::T_LONG;
|
|
else if (type == "unsigned char")
|
|
return PIC16Dbg::T_UCHAR;
|
|
else if (type == "unsigned short")
|
|
return PIC16Dbg::T_USHORT;
|
|
else if (type == "unsigned int")
|
|
return PIC16Dbg::T_UINT;
|
|
else if (type == "unsigned long")
|
|
return PIC16Dbg::T_ULONG;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
short PIC16DbgInfo::getClass(DIGlobalVariable DIGV) {
|
|
short ClassNo;
|
|
if (PAN::isLocalName(DIGV.getGlobal()->getName())) {
|
|
// Generating C_AUTO here fails due to error in linker. Change it once
|
|
// linker is fixed.
|
|
ClassNo = PIC16Dbg::C_STAT;
|
|
}
|
|
else if (DIGV.isLocalToUnit())
|
|
ClassNo = PIC16Dbg::C_STAT;
|
|
else
|
|
ClassNo = PIC16Dbg::C_EXT;
|
|
return ClassNo;
|
|
}
|
|
|
|
void PIC16DbgInfo::PopulateFunctsDI(Module &M) {
|
|
GlobalVariable *Root = M.getGlobalVariable("llvm.dbg.subprograms");
|
|
if (!Root)
|
|
return;
|
|
Constant *RootC = cast<Constant>(*Root->use_begin());
|
|
|
|
for (Value::use_iterator UI = RootC->use_begin(), UE = Root->use_end();
|
|
UI != UE; ++UI)
|
|
for (Value::use_iterator UUI = UI->use_begin(), UUE = UI->use_end();
|
|
UUI != UUE; ++UUI) {
|
|
GlobalVariable *GVSP = cast<GlobalVariable>(*UUI);
|
|
DISubprogram *SP = new DISubprogram(GVSP);
|
|
std::string Name;
|
|
SP->getLinkageName(Name);
|
|
FunctNameMap[Name] = SP;
|
|
}
|
|
return;
|
|
}
|
|
|
|
DISubprogram* PIC16DbgInfo::getFunctDI(std::string FunctName) {
|
|
return FunctNameMap[FunctName];
|
|
}
|
|
|
|
void PIC16DbgInfo::EmitFunctBeginDI(const Function *F) {
|
|
std::string FunctName = F->getName();
|
|
DISubprogram *SP = getFunctDI(FunctName);
|
|
if (SP) {
|
|
std::string FunctBeginSym = ".bf." + FunctName;
|
|
std::string BlockBeginSym = ".bb." + FunctName;
|
|
|
|
int FunctBeginLine = SP->getLineNumber();
|
|
int BFAux[PIC16Dbg::AuxSize] = {0};
|
|
BFAux[4] = FunctBeginLine;
|
|
BFAux[5] = FunctBeginLine >> 8;
|
|
// Emit debug directives for beginning of function.
|
|
EmitSymbol(FunctBeginSym, PIC16Dbg::C_FCN);
|
|
EmitAuxEntry(FunctBeginSym, BFAux, PIC16Dbg::AuxSize);
|
|
EmitSymbol(BlockBeginSym, PIC16Dbg::C_BLOCK);
|
|
EmitAuxEntry(BlockBeginSym, BFAux, PIC16Dbg::AuxSize);
|
|
}
|
|
}
|
|
|
|
void PIC16DbgInfo::EmitFunctEndDI(const Function *F, unsigned Line) {
|
|
std::string FunctName = F->getName();
|
|
DISubprogram *SP = getFunctDI(FunctName);
|
|
if (SP) {
|
|
std::string FunctEndSym = ".ef." + FunctName;
|
|
std::string BlockEndSym = ".eb." + FunctName;
|
|
|
|
// Emit debug directives for end of function.
|
|
EmitSymbol(BlockEndSym, PIC16Dbg::C_BLOCK);
|
|
int EFAux[PIC16Dbg::AuxSize] = {0};
|
|
// 5th and 6th byte stand for line number.
|
|
EFAux[4] = Line;
|
|
EFAux[5] = Line >> 8;
|
|
EmitAuxEntry(BlockEndSym, EFAux, PIC16Dbg::AuxSize);
|
|
EmitSymbol(FunctEndSym, PIC16Dbg::C_FCN);
|
|
EmitAuxEntry(FunctEndSym, EFAux, PIC16Dbg::AuxSize);
|
|
}
|
|
}
|
|
|
|
/// EmitAuxEntry - Emit Auxiliary debug information.
|
|
///
|
|
void PIC16DbgInfo::EmitAuxEntry(const std::string VarName, int Aux[], int num) {
|
|
O << "\n\t.dim " << VarName << ", 1" ;
|
|
for (int i = 0; i<num; i++)
|
|
O << "," << Aux[i];
|
|
}
|
|
|
|
void PIC16DbgInfo::EmitSymbol(std::string Name, int Class) {
|
|
O << "\n\t" << ".def "<< Name << ", debug, class = " << Class;
|
|
}
|
|
|
|
void PIC16DbgInfo::EmitVarDebugInfo(Module &M) {
|
|
GlobalVariable *Root = M.getGlobalVariable("llvm.dbg.global_variables");
|
|
if (!Root)
|
|
return;
|
|
|
|
Constant *RootC = cast<Constant>(*Root->use_begin());
|
|
for (Value::use_iterator UI = RootC->use_begin(), UE = Root->use_end();
|
|
UI != UE; ++UI) {
|
|
for (Value::use_iterator UUI = UI->use_begin(), UUE = UI->use_end();
|
|
UUI != UUE; ++UUI) {
|
|
DIGlobalVariable DIGV(cast<GlobalVariable>(*UUI));
|
|
DIType Ty = DIGV.getType();
|
|
unsigned short TypeNo = 0;
|
|
bool HasAux = false;
|
|
int Aux[PIC16Dbg::AuxSize] = { 0 };
|
|
std::string TypeName = "";
|
|
std::string VarName = TAI->getGlobalPrefix()+DIGV.getGlobal()->getName();
|
|
PopulateDebugInfo(Ty, TypeNo, HasAux, Aux, TypeName);
|
|
// Emit debug info only if type information is availaible.
|
|
if (TypeNo != PIC16Dbg::T_NULL) {
|
|
O << "\n\t.type " << VarName << ", " << TypeNo;
|
|
short ClassNo = getClass(DIGV);
|
|
O << "\n\t.class " << VarName << ", " << ClassNo;
|
|
if (HasAux) {
|
|
if (TypeName != "") {
|
|
// Emit debug info for structure and union objects after
|
|
// .dim directive supports structure/union tag name in aux entry.
|
|
/* O << "\n\t.dim " << VarName << ", 1," << TypeName;
|
|
for (int i = 0; i<PIC16Dbg::AuxSize; i++)
|
|
O << "," << Aux[i];*/
|
|
}
|
|
else {
|
|
EmitAuxEntry(VarName, Aux, PIC16Dbg::AuxSize);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
O << "\n";
|
|
}
|
|
|
|
void PIC16DbgInfo::EmitFileDirective(Module &M) {
|
|
GlobalVariable *CU = M.getNamedGlobal("llvm.dbg.compile_unit");
|
|
if (CU) {
|
|
DICompileUnit DIUnit(CU);
|
|
std::string Dir, FN;
|
|
std::string File = DIUnit.getDirectory(Dir) + "/" + DIUnit.getFilename(FN);
|
|
O << "\n\t.file\t\"" << File << "\"\n" ;
|
|
CurFile = File;
|
|
}
|
|
}
|
|
|
|
void PIC16DbgInfo::EmitFileDirective(const Function *F) {
|
|
std::string FunctName = F->getName();
|
|
DISubprogram *SP = getFunctDI(FunctName);
|
|
if (SP) {
|
|
std::string Dir, FN;
|
|
DICompileUnit CU = SP->getCompileUnit();
|
|
std::string File = CU.getDirectory(Dir) + "/" + CU.getFilename(FN);
|
|
if ( File != CurFile) {
|
|
EmitEOF();
|
|
O << "\n\t.file\t\"" << File << "\"\n" ;
|
|
CurFile = File;
|
|
}
|
|
}
|
|
}
|
|
|
|
void PIC16DbgInfo::EmitEOF() {
|
|
if (CurFile != "")
|
|
O << "\n\t.EOF";
|
|
}
|
|
|