llvm/lib/Target/PIC16/PIC16DebugInfo.cpp - toolchain/llvm-project - Gitiles


 //===-- 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 "PIC16ABINames.h"
 #include "PIC16DebugInfo.h"
 #include "llvm/GlobalVariable.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/Support/DebugLoc.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/ADT/SmallString.h"

 using namespace llvm;

 /// PopulateDebugInfo - Populate the TypeNo, Aux[] and TagName from Ty.
 ///
 void PIC16DbgInfo::PopulateDebugInfo (DIType Ty, unsigned short &TypeNo,
                                       bool &HasAux, int Aux[],
                                       std::string &TagName) {
   if (Ty.isBasicType())
     PopulateBasicTypeInfo (Ty, TypeNo);
   else if (Ty.isCompositeType())
     PopulateCompositeTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
   else if (Ty.isDerivedType())
     PopulateDerivedTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
   else {
     TypeNo = PIC16Dbg::T_NULL;
     HasAux = false;
   }
   return;
 }

 /// PopulateBasicTypeInfo- Populate TypeNo for basic type from Ty.
 ///
 void PIC16DbgInfo::PopulateBasicTypeInfo (DIType Ty, unsigned short &TypeNo) {
   std::string Name = Ty.getName();
   unsigned short BaseTy = GetTypeDebugNumber(Name);
   TypeNo = TypeNo << PIC16Dbg::S_BASIC;
   TypeNo = TypeNo | (0xffff & BaseTy);
 }

 /// PopulateDerivedTypeInfo - Populate TypeNo, Aux[], TagName for derived type
 /// from Ty. Derived types are mostly pointers.
 ///
 void PIC16DbgInfo::PopulateDerivedTypeInfo (DIType Ty, unsigned short &TypeNo,
                                             bool &HasAux, int Aux[],
                                             std::string &TagName) {

   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;
   }

   // We also need to encode the the information about the base type of
   // pointer in TypeNo.
   DIType BaseType = DIDerivedType(Ty.getNode()).getTypeDerivedFrom();
   PopulateDebugInfo(BaseType, TypeNo, HasAux, Aux, TagName);
 }

 /// PopulateArrayTypeInfo - Populate TypeNo, Aux[] for array from Ty.
 void PIC16DbgInfo::PopulateArrayTypeInfo (DIType Ty, unsigned short &TypeNo,
                                           bool &HasAux, int Aux[],
                                           std::string &TagName) {

   DICompositeType CTy = DICompositeType(Ty.getNode());
   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.getNode());
       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 & 0xff;
   Aux[7] = size >> 8;
   DIType BaseType = CTy.getTypeDerivedFrom();
   PopulateDebugInfo(BaseType, TypeNo, HasAux, Aux, TagName);
 }

 /// PopulateStructOrUnionTypeInfo - Populate TypeNo, Aux[] , TagName for
 /// structure or union.
 ///
 void PIC16DbgInfo::PopulateStructOrUnionTypeInfo (DIType Ty,
                                                   unsigned short &TypeNo,
                                                   bool &HasAux, int Aux[],
                                                   std::string &TagName) {
   DICompositeType CTy = DICompositeType(Ty.getNode());
   TypeNo = TypeNo << PIC16Dbg::S_BASIC;
   if (Ty.getTag() == dwarf::DW_TAG_structure_type)
     TypeNo = TypeNo | PIC16Dbg::T_STRUCT;
   else
     TypeNo = TypeNo | PIC16Dbg::T_UNION;
   TagName = CTy.getName();
   // UniqueSuffix is .number where number is obtained from
   // llvm.dbg.composite<number>.
   // FIXME: This will break when composite type is not represented by
   // llvm.dbg.composite* global variable. Since we need to revisit
   // PIC16DebugInfo implementation anyways after the MDNodes based
   // framework is done, let us continue with the way it is.
   std::string UniqueSuffix = "." + Ty.getNode()->getNameStr().substr(18);
   TagName += UniqueSuffix;
   unsigned short size = CTy.getSizeInBits()/8;
   // 7th and 8th byte represent size.
   HasAux = true;
   Aux[6] = size & 0xff;
   Aux[7] = size >> 8;
 }

 /// PopulateEnumTypeInfo - Populate TypeNo for enum from Ty.
 void PIC16DbgInfo::PopulateEnumTypeInfo (DIType Ty, unsigned short &TypeNo) {
   TypeNo = TypeNo << PIC16Dbg::S_BASIC;
   TypeNo = TypeNo | PIC16Dbg::T_ENUM;
 }

 /// PopulateCompositeTypeInfo - Populate TypeNo, Aux[] and TagName for
 /// composite types from Ty.
 ///
 void PIC16DbgInfo::PopulateCompositeTypeInfo (DIType Ty, unsigned short &TypeNo,
                                               bool &HasAux, int Aux[],
                                               std::string &TagName) {
   switch (Ty.getTag()) {
     case dwarf::DW_TAG_array_type: {
       PopulateArrayTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
       break;
     }
     case dwarf:: DW_TAG_union_type:
     case dwarf::DW_TAG_structure_type: {
       PopulateStructOrUnionTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
       break;
     }
     case dwarf::DW_TAG_enumeration_type: {
       PopulateEnumTypeInfo (Ty, TypeNo);
       break;
     }
     default:
       TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
   }
 }

 /// GetTypeDebugNumber - Get debug type number for given type.
 ///
 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;
 }

 /// GetStorageClass - Get storage class for give debug variable.
 ///
 short PIC16DbgInfo::getStorageClass(DIGlobalVariable DIGV) {
   short ClassNo;
   if (PAN::isLocalName(DIGV.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;
 }

 /// BeginModule - Emit necessary debug info to start a Module and do other
 /// required initializations.
 void PIC16DbgInfo::BeginModule(Module &M) {
   // Emit file directive for module.
   DebugInfoFinder DbgFinder;
   DbgFinder.processModule(M);
   if (DbgFinder.compile_unit_count() != 0) {
     // FIXME : What if more then one CUs are present in a module ?
     MDNode *CU = *DbgFinder.compile_unit_begin();
     EmitDebugDirectives = true;
     SwitchToCU(CU);
   }
   // Emit debug info for decls of composite types.
   EmitCompositeTypeDecls(M);
 }

 /// Helper to find first valid debug loc for a function.
 ///
 static const DebugLoc GetDebugLocForFunction(const MachineFunction &MF) {
   DebugLoc DL;
   for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
        I != E; ++I) {
     for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
          II != E; ++II) {
       DL = II->getDebugLoc();
       if (!DL.isUnknown())
         return DL;
     }
   }
   return DL;
 }

 /// BeginFunction - Emit necessary debug info to start a function.
 ///
 void PIC16DbgInfo::BeginFunction(const MachineFunction &MF) {
   if (! EmitDebugDirectives) return;

   // Retreive the first valid debug Loc and process it.
   const DebugLoc &DL = GetDebugLocForFunction(MF);
   // Emit debug info only if valid debug info is available.
   if (!DL.isUnknown()) {
     ChangeDebugLoc(MF, DL, true);
     EmitFunctBeginDI(MF.getFunction());
   }
   // Set current line to 0 so that.line directive is genearted after .bf.
   CurLine = 0;
 }

 /// ChangeDebugLoc - Take necessary steps when DebugLoc changes.
 /// CurFile and CurLine may change as a result of this.
 ///
 void PIC16DbgInfo::ChangeDebugLoc(const MachineFunction &MF,
                                   const DebugLoc &DL, bool IsInBeginFunction) {
   if (! EmitDebugDirectives) return;
   assert (! DL.isUnknown()  && "can't change to invalid debug loc");

   MDNode *CU = MF.getDebugLocTuple(DL).Scope;
   unsigned line = MF.getDebugLocTuple(DL).Line;

   SwitchToCU(CU);
   SwitchToLine(line, IsInBeginFunction);
 }

 /// SwitchToLine - Emit line directive for a new line.
 ///
 void PIC16DbgInfo::SwitchToLine(unsigned Line, bool IsInBeginFunction) {
   if (CurLine == Line) return;
   if (!IsInBeginFunction)  O << "\n\t.line " << Line << "\n";
   CurLine = Line;
 }

 /// EndFunction - Emit .ef for end of function.
 ///
 void PIC16DbgInfo::EndFunction(const MachineFunction &MF) {
   if (! EmitDebugDirectives) return;
   const DebugLoc &DL = GetDebugLocForFunction(MF);
   // Emit debug info only if valid debug info is available.
   if (!DL.isUnknown())
     EmitFunctEndDI(MF.getFunction(), CurLine);
 }

 /// EndModule - Emit .eof for end of module.
 ///
 void PIC16DbgInfo::EndModule(Module &M) {
   if (! EmitDebugDirectives) return;
   EmitVarDebugInfo(M);
   if (CurFile != "") O << "\n\t.eof";
 }

 /// EmitCompositeTypeElements - Emit debug information for members of a
 /// composite type.
 ///
 void PIC16DbgInfo::EmitCompositeTypeElements (DICompositeType CTy,
                                               std::string SuffixNo) {
   unsigned long Value = 0;
   DIArray Elements = CTy.getTypeArray();
   for (unsigned i = 0, N = Elements.getNumElements(); i < N; i++) {
     DIDescriptor Element = Elements.getElement(i);
     unsigned short TypeNo = 0;
     bool HasAux = false;
     int ElementAux[PIC16Dbg::AuxSize] = { 0 };
     std::string TagName = "";
     DIDerivedType DITy(Element.getNode());
     const char *ElementName = DITy.getName();
     unsigned short ElementSize = DITy.getSizeInBits()/8;
     // Get mangleddd name for this structure/union  element.
     std::string MangMemName = ElementName + SuffixNo;
     PopulateDebugInfo(DITy, TypeNo, HasAux, ElementAux, TagName);
     short Class = 0;
     if( CTy.getTag() == dwarf::DW_TAG_union_type)
       Class = PIC16Dbg::C_MOU;
     else if  (CTy.getTag() == dwarf::DW_TAG_structure_type)
       Class = PIC16Dbg::C_MOS;
     EmitSymbol(MangMemName.c_str(), Class, TypeNo, Value);
     if (CTy.getTag() == dwarf::DW_TAG_structure_type)
       Value += ElementSize;
     if (HasAux)
       EmitAuxEntry(MangMemName.c_str(), ElementAux, PIC16Dbg::AuxSize, TagName);
   }
 }

 /// EmitCompositeTypeDecls - Emit composite type declarations like structure
 /// and union declarations.
 ///
 void PIC16DbgInfo::EmitCompositeTypeDecls(Module &M) {
   DebugInfoFinder DbgFinder;
   DbgFinder.processModule(M);
   for (DebugInfoFinder::iterator I = DbgFinder.type_begin(),
          E = DbgFinder.type_end(); I != E; ++I) {
     DICompositeType CTy(*I);
     if (CTy.isNull())
       continue;
     if (CTy.getTag() == dwarf::DW_TAG_union_type ||
         CTy.getTag() == dwarf::DW_TAG_structure_type ) {
       const char *Name = CTy.getName();
       // Get the number after llvm.dbg.composite and make UniqueSuffix from
       // it.
       std::string DIVar = CTy.getNode()->getNameStr();
       std::string UniqueSuffix = "." + DIVar.substr(18);
       std::string MangledCTyName = Name + UniqueSuffix;
       unsigned short size = CTy.getSizeInBits()/8;
       int Aux[PIC16Dbg::AuxSize] = {0};
       // 7th and 8th byte represent size of structure/union.
       Aux[6] = size & 0xff;
       Aux[7] = size >> 8;
       // Emit .def for structure/union tag.
       if( CTy.getTag() == dwarf::DW_TAG_union_type)
         EmitSymbol(MangledCTyName.c_str(), PIC16Dbg::C_UNTAG);
       else if  (CTy.getTag() == dwarf::DW_TAG_structure_type)
         EmitSymbol(MangledCTyName.c_str(), PIC16Dbg::C_STRTAG);

       // Emit auxiliary debug information for structure/union tag.
       EmitAuxEntry(MangledCTyName.c_str(), Aux, PIC16Dbg::AuxSize);

       // Emit members.
       EmitCompositeTypeElements (CTy, UniqueSuffix);

       // Emit mangled Symbol for end of structure/union.
       std::string EOSSymbol = ".eos" + UniqueSuffix;
       EmitSymbol(EOSSymbol.c_str(), PIC16Dbg::C_EOS);
       EmitAuxEntry(EOSSymbol.c_str(), Aux, PIC16Dbg::AuxSize,
                    MangledCTyName.c_str());
     }
   }
 }


 /// EmitFunctBeginDI - Emit .bf for function.
 ///
 void PIC16DbgInfo::EmitFunctBeginDI(const Function *F) {
   std::string FunctName = F->getName();
   if (EmitDebugDirectives) {
     std::string FunctBeginSym = ".bf." + FunctName;
     std::string BlockBeginSym = ".bb." + FunctName;

     int BFAux[PIC16Dbg::AuxSize] = {0};
     BFAux[4] = CurLine;
     BFAux[5] = CurLine >> 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);
   }
 }

 /// EmitFunctEndDI - Emit .ef for function end.
 ///
 void PIC16DbgInfo::EmitFunctEndDI(const Function *F, unsigned Line) {
   std::string FunctName = F->getName();
   if (EmitDebugDirectives) {
     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] = CurLine;
     EFAux[5] = CurLine >> 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,
                                 std::string TagName) {
   O << "\n\t.dim " << VarName << ", 1" ;
   // TagName is emitted in case of structure/union objects.
   if (TagName != "")
     O << ", " << TagName;
   for (int i = 0; i<Num; i++)
     O << "," << Aux[i];
 }

 /// EmitSymbol - Emit .def for a symbol. Value is offset for the member.
 ///
 void PIC16DbgInfo::EmitSymbol(std::string Name, short Class, unsigned short
                               Type, unsigned long Value) {
   O << "\n\t" << ".def "<< Name << ", type = " << Type << ", class = "
     << Class;
   if (Value > 0)
     O  << ", value = " << Value;
 }

 /// EmitVarDebugInfo - Emit debug information for all variables.
 ///
 void PIC16DbgInfo::EmitVarDebugInfo(Module &M) {
   DebugInfoFinder DbgFinder;
   DbgFinder.processModule(M);

   for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
          E = DbgFinder.global_variable_end(); I != E; ++I) {
     DIGlobalVariable DIGV(*I);
     DIType Ty = DIGV.getType();
     unsigned short TypeNo = 0;
     bool HasAux = false;
     int Aux[PIC16Dbg::AuxSize] = { 0 };
     std::string TagName = "";
     std::string VarName = DIGV.getName();
     VarName = MAI->getGlobalPrefix() + VarName;
     PopulateDebugInfo(Ty, TypeNo, HasAux, Aux, TagName);
     // Emit debug info only if type information is availaible.
     if (TypeNo != PIC16Dbg::T_NULL) {
       O << "\n\t.type " << VarName << ", " << TypeNo;
       short ClassNo = getStorageClass(DIGV);
       O << "\n\t.class " << VarName << ", " << ClassNo;
       if (HasAux)
         EmitAuxEntry(VarName, Aux, PIC16Dbg::AuxSize, TagName);
     }
   }
   O << "\n";
 }

 /// SwitchToCU - Switch to a new compilation unit.
 ///
 void PIC16DbgInfo::SwitchToCU(MDNode *CU) {
   // Get the file path from CU.
   DICompileUnit cu(CU);
   std::string DirName = cu.getDirectory();
   std::string FileName = cu.getFilename();
   std::string FilePath = DirName + "/" + FileName;

   // Nothing to do if source file is still same.
   if ( FilePath == CurFile ) return;

   // Else, close the current one and start a new.
   if (CurFile != "") O << "\n\t.eof";
   O << "\n\t.file\t\"" << FilePath << "\"\n" ;
   CurFile = FilePath;
   CurLine = 0;
 }

 /// EmitEOF - Emit .eof for end of file.
 ///
 void PIC16DbgInfo::EmitEOF() {
   if (CurFile != "")
     O << "\n\t.EOF";
 }

	//===-- 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 "PIC16ABINames.h"
	#include "PIC16DebugInfo.h"
	#include "llvm/GlobalVariable.h"
	#include "llvm/CodeGen/MachineFunction.h"
	#include "llvm/MC/MCAsmInfo.h"
	#include "llvm/Support/DebugLoc.h"
	#include "llvm/Support/FormattedStream.h"
	#include "llvm/ADT/SmallString.h"

	using namespace llvm;

	/// PopulateDebugInfo - Populate the TypeNo, Aux[] and TagName from Ty.
	///
	void PIC16DbgInfo::PopulateDebugInfo (DIType Ty, unsigned short &TypeNo,
	bool &HasAux, int Aux[],
	std::string &TagName) {
	if (Ty.isBasicType())
	PopulateBasicTypeInfo (Ty, TypeNo);
	else if (Ty.isCompositeType())
	PopulateCompositeTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
	else if (Ty.isDerivedType())
	PopulateDerivedTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
	else {
	TypeNo = PIC16Dbg::T_NULL;
	HasAux = false;
	}
	return;
	}

	/// PopulateBasicTypeInfo- Populate TypeNo for basic type from Ty.
	///
	void PIC16DbgInfo::PopulateBasicTypeInfo (DIType Ty, unsigned short &TypeNo) {
	std::string Name = Ty.getName();
	unsigned short BaseTy = GetTypeDebugNumber(Name);
	TypeNo = TypeNo << PIC16Dbg::S_BASIC;
	TypeNo = TypeNo \| (0xffff & BaseTy);
	}

	/// PopulateDerivedTypeInfo - Populate TypeNo, Aux[], TagName for derived type
	/// from Ty. Derived types are mostly pointers.
	///
	void PIC16DbgInfo::PopulateDerivedTypeInfo (DIType Ty, unsigned short &TypeNo,
	bool &HasAux, int Aux[],
	std::string &TagName) {

	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;
	}

	// We also need to encode the the information about the base type of
	// pointer in TypeNo.
	DIType BaseType = DIDerivedType(Ty.getNode()).getTypeDerivedFrom();
	PopulateDebugInfo(BaseType, TypeNo, HasAux, Aux, TagName);
	}

	/// PopulateArrayTypeInfo - Populate TypeNo, Aux[] for array from Ty.
	void PIC16DbgInfo::PopulateArrayTypeInfo (DIType Ty, unsigned short &TypeNo,
	bool &HasAux, int Aux[],
	std::string &TagName) {

	DICompositeType CTy = DICompositeType(Ty.getNode());
	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.getNode());
	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 & 0xff;
	Aux[7] = size >> 8;
	DIType BaseType = CTy.getTypeDerivedFrom();
	PopulateDebugInfo(BaseType, TypeNo, HasAux, Aux, TagName);
	}

	/// PopulateStructOrUnionTypeInfo - Populate TypeNo, Aux[] , TagName for
	/// structure or union.
	///
	void PIC16DbgInfo::PopulateStructOrUnionTypeInfo (DIType Ty,
	unsigned short &TypeNo,
	bool &HasAux, int Aux[],
	std::string &TagName) {
	DICompositeType CTy = DICompositeType(Ty.getNode());
	TypeNo = TypeNo << PIC16Dbg::S_BASIC;
	if (Ty.getTag() == dwarf::DW_TAG_structure_type)
	TypeNo = TypeNo \| PIC16Dbg::T_STRUCT;
	else
	TypeNo = TypeNo \| PIC16Dbg::T_UNION;
	TagName = CTy.getName();
	// UniqueSuffix is .number where number is obtained from
	// llvm.dbg.composite<number>.
	// FIXME: This will break when composite type is not represented by
	// llvm.dbg.composite* global variable. Since we need to revisit
	// PIC16DebugInfo implementation anyways after the MDNodes based
	// framework is done, let us continue with the way it is.
	std::string UniqueSuffix = "." + Ty.getNode()->getNameStr().substr(18);
	TagName += UniqueSuffix;
	unsigned short size = CTy.getSizeInBits()/8;
	// 7th and 8th byte represent size.
	HasAux = true;
	Aux[6] = size & 0xff;
	Aux[7] = size >> 8;
	}

	/// PopulateEnumTypeInfo - Populate TypeNo for enum from Ty.
	void PIC16DbgInfo::PopulateEnumTypeInfo (DIType Ty, unsigned short &TypeNo) {
	TypeNo = TypeNo << PIC16Dbg::S_BASIC;
	TypeNo = TypeNo \| PIC16Dbg::T_ENUM;
	}

	/// PopulateCompositeTypeInfo - Populate TypeNo, Aux[] and TagName for
	/// composite types from Ty.
	///
	void PIC16DbgInfo::PopulateCompositeTypeInfo (DIType Ty, unsigned short &TypeNo,
	bool &HasAux, int Aux[],
	std::string &TagName) {
	switch (Ty.getTag()) {
	case dwarf::DW_TAG_array_type: {
	PopulateArrayTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
	break;
	}
	case dwarf:: DW_TAG_union_type:
	case dwarf::DW_TAG_structure_type: {
	PopulateStructOrUnionTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
	break;
	}
	case dwarf::DW_TAG_enumeration_type: {
	PopulateEnumTypeInfo (Ty, TypeNo);
	break;
	}
	default:
	TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
	}
	}

	/// GetTypeDebugNumber - Get debug type number for given type.
	///
	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;
	}

	/// GetStorageClass - Get storage class for give debug variable.
	///
	short PIC16DbgInfo::getStorageClass(DIGlobalVariable DIGV) {
	short ClassNo;
	if (PAN::isLocalName(DIGV.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;
	}

	/// BeginModule - Emit necessary debug info to start a Module and do other
	/// required initializations.
	void PIC16DbgInfo::BeginModule(Module &M) {
	// Emit file directive for module.
	DebugInfoFinder DbgFinder;
	DbgFinder.processModule(M);
	if (DbgFinder.compile_unit_count() != 0) {
	// FIXME : What if more then one CUs are present in a module ?
	MDNode CU = DbgFinder.compile_unit_begin();
	EmitDebugDirectives = true;
	SwitchToCU(CU);
	}
	// Emit debug info for decls of composite types.
	EmitCompositeTypeDecls(M);
	}

	/// Helper to find first valid debug loc for a function.
	///
	static const DebugLoc GetDebugLocForFunction(const MachineFunction &MF) {
	DebugLoc DL;
	for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
	I != E; ++I) {
	for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
	II != E; ++II) {
	DL = II->getDebugLoc();
	if (!DL.isUnknown())
	return DL;
	}
	}
	return DL;
	}

	/// BeginFunction - Emit necessary debug info to start a function.
	///
	void PIC16DbgInfo::BeginFunction(const MachineFunction &MF) {
	if (! EmitDebugDirectives) return;

	// Retreive the first valid debug Loc and process it.
	const DebugLoc &DL = GetDebugLocForFunction(MF);
	// Emit debug info only if valid debug info is available.
	if (!DL.isUnknown()) {
	ChangeDebugLoc(MF, DL, true);
	EmitFunctBeginDI(MF.getFunction());
	}
	// Set current line to 0 so that.line directive is genearted after .bf.
	CurLine = 0;
	}

	/// ChangeDebugLoc - Take necessary steps when DebugLoc changes.
	/// CurFile and CurLine may change as a result of this.
	///
	void PIC16DbgInfo::ChangeDebugLoc(const MachineFunction &MF,
	const DebugLoc &DL, bool IsInBeginFunction) {
	if (! EmitDebugDirectives) return;
	assert (! DL.isUnknown() && "can't change to invalid debug loc");

	MDNode *CU = MF.getDebugLocTuple(DL).Scope;
	unsigned line = MF.getDebugLocTuple(DL).Line;

	SwitchToCU(CU);
	SwitchToLine(line, IsInBeginFunction);
	}

	/// SwitchToLine - Emit line directive for a new line.
	///
	void PIC16DbgInfo::SwitchToLine(unsigned Line, bool IsInBeginFunction) {
	if (CurLine == Line) return;
	if (!IsInBeginFunction) O << "\n\t.line " << Line << "\n";
	CurLine = Line;
	}

	/// EndFunction - Emit .ef for end of function.
	///
	void PIC16DbgInfo::EndFunction(const MachineFunction &MF) {
	if (! EmitDebugDirectives) return;
	const DebugLoc &DL = GetDebugLocForFunction(MF);
	// Emit debug info only if valid debug info is available.
	if (!DL.isUnknown())
	EmitFunctEndDI(MF.getFunction(), CurLine);
	}

	/// EndModule - Emit .eof for end of module.
	///
	void PIC16DbgInfo::EndModule(Module &M) {
	if (! EmitDebugDirectives) return;
	EmitVarDebugInfo(M);
	if (CurFile != "") O << "\n\t.eof";
	}

	/// EmitCompositeTypeElements - Emit debug information for members of a
	/// composite type.
	///
	void PIC16DbgInfo::EmitCompositeTypeElements (DICompositeType CTy,
	std::string SuffixNo) {
	unsigned long Value = 0;
	DIArray Elements = CTy.getTypeArray();
	for (unsigned i = 0, N = Elements.getNumElements(); i < N; i++) {
	DIDescriptor Element = Elements.getElement(i);
	unsigned short TypeNo = 0;
	bool HasAux = false;
	int ElementAux[PIC16Dbg::AuxSize] = { 0 };
	std::string TagName = "";
	DIDerivedType DITy(Element.getNode());
	const char *ElementName = DITy.getName();
	unsigned short ElementSize = DITy.getSizeInBits()/8;
	// Get mangleddd name for this structure/union element.
	std::string MangMemName = ElementName + SuffixNo;
	PopulateDebugInfo(DITy, TypeNo, HasAux, ElementAux, TagName);
	short Class = 0;
	if( CTy.getTag() == dwarf::DW_TAG_union_type)
	Class = PIC16Dbg::C_MOU;
	else if (CTy.getTag() == dwarf::DW_TAG_structure_type)
	Class = PIC16Dbg::C_MOS;
	EmitSymbol(MangMemName.c_str(), Class, TypeNo, Value);
	if (CTy.getTag() == dwarf::DW_TAG_structure_type)
	Value += ElementSize;
	if (HasAux)
	EmitAuxEntry(MangMemName.c_str(), ElementAux, PIC16Dbg::AuxSize, TagName);
	}
	}

	/// EmitCompositeTypeDecls - Emit composite type declarations like structure
	/// and union declarations.
	///
	void PIC16DbgInfo::EmitCompositeTypeDecls(Module &M) {
	DebugInfoFinder DbgFinder;
	DbgFinder.processModule(M);
	for (DebugInfoFinder::iterator I = DbgFinder.type_begin(),
	E = DbgFinder.type_end(); I != E; ++I) {
	DICompositeType CTy(*I);
	if (CTy.isNull())
	continue;
	if (CTy.getTag() == dwarf::DW_TAG_union_type \|\|
	CTy.getTag() == dwarf::DW_TAG_structure_type ) {
	const char *Name = CTy.getName();
	// Get the number after llvm.dbg.composite and make UniqueSuffix from
	// it.
	std::string DIVar = CTy.getNode()->getNameStr();
	std::string UniqueSuffix = "." + DIVar.substr(18);
	std::string MangledCTyName = Name + UniqueSuffix;
	unsigned short size = CTy.getSizeInBits()/8;
	int Aux[PIC16Dbg::AuxSize] = {0};
	// 7th and 8th byte represent size of structure/union.
	Aux[6] = size & 0xff;
	Aux[7] = size >> 8;
	// Emit .def for structure/union tag.
	if( CTy.getTag() == dwarf::DW_TAG_union_type)
	EmitSymbol(MangledCTyName.c_str(), PIC16Dbg::C_UNTAG);
	else if (CTy.getTag() == dwarf::DW_TAG_structure_type)
	EmitSymbol(MangledCTyName.c_str(), PIC16Dbg::C_STRTAG);

	// Emit auxiliary debug information for structure/union tag.
	EmitAuxEntry(MangledCTyName.c_str(), Aux, PIC16Dbg::AuxSize);

	// Emit members.
	EmitCompositeTypeElements (CTy, UniqueSuffix);

	// Emit mangled Symbol for end of structure/union.
	std::string EOSSymbol = ".eos" + UniqueSuffix;
	EmitSymbol(EOSSymbol.c_str(), PIC16Dbg::C_EOS);
	EmitAuxEntry(EOSSymbol.c_str(), Aux, PIC16Dbg::AuxSize,
	MangledCTyName.c_str());
	}
	}
	}


	/// EmitFunctBeginDI - Emit .bf for function.
	///
	void PIC16DbgInfo::EmitFunctBeginDI(const Function *F) {
	std::string FunctName = F->getName();
	if (EmitDebugDirectives) {
	std::string FunctBeginSym = ".bf." + FunctName;
	std::string BlockBeginSym = ".bb." + FunctName;

	int BFAux[PIC16Dbg::AuxSize] = {0};
	BFAux[4] = CurLine;
	BFAux[5] = CurLine >> 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);
	}
	}

	/// EmitFunctEndDI - Emit .ef for function end.
	///
	void PIC16DbgInfo::EmitFunctEndDI(const Function *F, unsigned Line) {
	std::string FunctName = F->getName();
	if (EmitDebugDirectives) {
	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] = CurLine;
	EFAux[5] = CurLine >> 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,
	std::string TagName) {
	O << "\n\t.dim " << VarName << ", 1" ;
	// TagName is emitted in case of structure/union objects.
	if (TagName != "")
	O << ", " << TagName;
	for (int i = 0; i<Num; i++)
	O << "," << Aux[i];
	}

	/// EmitSymbol - Emit .def for a symbol. Value is offset for the member.
	///
	void PIC16DbgInfo::EmitSymbol(std::string Name, short Class, unsigned short
	Type, unsigned long Value) {
	O << "\n\t" << ".def "<< Name << ", type = " << Type << ", class = "
	<< Class;
	if (Value > 0)
	O << ", value = " << Value;
	}

	/// EmitVarDebugInfo - Emit debug information for all variables.
	///
	void PIC16DbgInfo::EmitVarDebugInfo(Module &M) {
	DebugInfoFinder DbgFinder;
	DbgFinder.processModule(M);

	for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
	E = DbgFinder.global_variable_end(); I != E; ++I) {
	DIGlobalVariable DIGV(*I);
	DIType Ty = DIGV.getType();
	unsigned short TypeNo = 0;
	bool HasAux = false;
	int Aux[PIC16Dbg::AuxSize] = { 0 };
	std::string TagName = "";
	std::string VarName = DIGV.getName();
	VarName = MAI->getGlobalPrefix() + VarName;
	PopulateDebugInfo(Ty, TypeNo, HasAux, Aux, TagName);
	// Emit debug info only if type information is availaible.
	if (TypeNo != PIC16Dbg::T_NULL) {
	O << "\n\t.type " << VarName << ", " << TypeNo;
	short ClassNo = getStorageClass(DIGV);
	O << "\n\t.class " << VarName << ", " << ClassNo;
	if (HasAux)
	EmitAuxEntry(VarName, Aux, PIC16Dbg::AuxSize, TagName);
	}
	}
	O << "\n";
	}

	/// SwitchToCU - Switch to a new compilation unit.
	///
	void PIC16DbgInfo::SwitchToCU(MDNode *CU) {
	// Get the file path from CU.
	DICompileUnit cu(CU);
	std::string DirName = cu.getDirectory();
	std::string FileName = cu.getFilename();
	std::string FilePath = DirName + "/" + FileName;

	// Nothing to do if source file is still same.
	if ( FilePath == CurFile ) return;

	// Else, close the current one and start a new.
	if (CurFile != "") O << "\n\t.eof";
	O << "\n\t.file\t\"" << FilePath << "\"\n" ;
	CurFile = FilePath;
	CurLine = 0;
	}

	/// EmitEOF - Emit .eof for end of file.
	///
	void PIC16DbgInfo::EmitEOF() {
	if (CurFile != "")
	O << "\n\t.EOF";
	}