PIC16AsmPrinter.cpp [plain text]
#include "PIC16ABINames.h"
#include "PIC16AsmPrinter.h"
#include "PIC16Section.h"
#include "PIC16MCAsmInfo.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Function.h"
#include "llvm/Module.h"
#include "llvm/CodeGen/DwarfWriter.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/DwarfWriter.h"
#include "llvm/CodeGen/MachineModuleInfo.h"
#include "llvm/MC/MCStreamer.h"
#include "llvm/MC/MCSymbol.h"
#include "llvm/Target/Mangler.h"
#include "llvm/Target/TargetRegistry.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FormattedStream.h"
#include <cstring>
using namespace llvm;
#include "PIC16GenAsmWriter.inc"
PIC16AsmPrinter::PIC16AsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
MCStreamer &Streamer)
: AsmPrinter(O, TM, Streamer), DbgInfo(O, TM.getMCAsmInfo()) {
PTLI = static_cast<PIC16TargetLowering*>(TM.getTargetLowering());
PMAI = static_cast<const PIC16MCAsmInfo*>(TM.getMCAsmInfo());
PTOF = (PIC16TargetObjectFile *)&PTLI->getObjFileLowering();
}
void PIC16AsmPrinter::EmitInstruction(const MachineInstr *MI) {
printInstruction(MI);
OutStreamer.AddBlankLine();
}
static int getFunctionColor(const Function *F) {
if (F->hasSection()) {
std::string Sectn = F->getSection();
std::string StrToFind = "Overlay=";
std::string::size_type Pos = Sectn.find(StrToFind);
if (Pos != std::string::npos) {
Pos += StrToFind.length();
std::string Color = "";
char c = Sectn.at(Pos);
while (c >= '0' && c<= '9') {
Color.append(1,c);
Pos++;
if (Pos >= Sectn.length())
break;
c = Sectn.at(Pos);
}
return atoi(Color.c_str());
}
}
return -1;
}
void PIC16AsmPrinter::ColorAutoSection(const Function *F) {
std::string SectionName = PAN::getAutosSectionName(CurrentFnSym->getName());
PIC16Section* Section = PTOF->findPIC16Section(SectionName);
if (Section != NULL) {
int Color = getFunctionColor(F);
if (Color >= 0)
Section->setColor(Color);
}
}
bool PIC16AsmPrinter::runOnMachineFunction(MachineFunction &MF) {
SetupMachineFunction(MF);
const Function *F = MF.getFunction();
ColorAutoSection(F);
EmitFunctionFrame(MF);
DbgInfo.BeginFunction(MF);
const MCSection *fCodeSection =
getObjFileLowering().SectionForCode(CurrentFnSym->getName(),
PAN::isISR(F->getSection()));
O << "\n";
OutStreamer.SwitchSection(fCodeSection);
O << "\tretlw low(" << PAN::getFrameLabel(CurrentFnSym->getName()) << ")\n";
O << "\tretlw high(" << PAN::getFrameLabel(CurrentFnSym->getName()) << ")\n";
O << *CurrentFnSym << ":\n";
DebugLoc CurDL;
O << "\n";
for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
I != E; ++I) {
if (I != MF.begin()) {
EmitBasicBlockStart(I);
}
for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
II != E; ++II) {
const DebugLoc DL = II->getDebugLoc();
if (!DL.isUnknown() && DL != CurDL) {
DbgInfo.ChangeDebugLoc(MF, DL);
CurDL = DL;
}
EmitInstruction(II);
}
}
DbgInfo.EndFunction(MF);
return false; }
void PIC16AsmPrinter::printOperand(const MachineInstr *MI, int opNum) {
const MachineOperand &MO = MI->getOperand(opNum);
const Function *F = MI->getParent()->getParent()->getFunction();
switch (MO.getType()) {
case MachineOperand::MO_Register:
{
std::string RegName = getRegisterName(MO.getReg());
if ((MI->getOpcode() == PIC16::load_indirect) ||
(MI->getOpcode() == PIC16::store_indirect))
{
RegName.replace (0, 3, "INDF");
}
O << RegName;
}
return;
case MachineOperand::MO_Immediate:
O << (int)MO.getImm();
return;
case MachineOperand::MO_GlobalAddress: {
MCSymbol *Sym = Mang->getSymbol(MO.getGlobal());
if (PAN::isMemIntrinsic(Sym->getName()))
LibcallDecls.push_back(createESName(Sym->getName()));
O << *Sym;
break;
}
case MachineOperand::MO_ExternalSymbol: {
const char *Sname = MO.getSymbolName();
std::string Printname = Sname;
if (PAN::isIntrinsicStuff(Printname)) {
if (PAN::isISR(F->getSection())) {
Printname = PAN::Rename(Sname);
}
LibcallDecls.push_back(createESName(Printname));
}
O << Printname;
break;
}
case MachineOperand::MO_MachineBasicBlock:
O << *MO.getMBB()->getSymbol();
return;
default:
llvm_unreachable(" Operand type not supported.");
}
}
void PIC16AsmPrinter::printCCOperand(const MachineInstr *MI, int opNum) {
int CC = (int)MI->getOperand(opNum).getImm();
O << PIC16CondCodeToString((PIC16CC::CondCodes)CC);
}
static bool is_before(const char *s1, const char *s2) {
return strcmp(s1, s2) <= 0;
}
static bool is_duplicate(const char *s1, const char *s2) {
return !strcmp(s1, s2);
}
void PIC16AsmPrinter::printLibcallDecls() {
if (LibcallDecls.empty()) return;
O << MAI->getCommentString() << "External decls for libcalls - BEGIN." <<"\n";
LibcallDecls.sort(is_before);
LibcallDecls.unique(is_duplicate);
for (std::list<const char*>::const_iterator I = LibcallDecls.begin();
I != LibcallDecls.end(); I++) {
O << MAI->getExternDirective() << *I << "\n";
}
O << MAI->getCommentString() << "External decls for libcalls - END." <<"\n";
}
bool PIC16AsmPrinter::doInitialization(Module &M) {
bool Result = AsmPrinter::doInitialization(M);
O << "\n#include p16f1xxx.inc";
O << "\n#include stdmacros.inc";
for (Module::global_iterator I = M.global_begin(), E = M.global_end();
I != E; ++I) {
if (I->isDeclaration()) {
ExternalVarDecls.push_back(I);
continue;
}
if (I->hasExternalLinkage() || I->hasCommonLinkage()) {
ExternalVarDefs.push_back(I);
}
if (!I->hasAvailableExternallyLinkage()) {
const MCSection *S = getObjFileLowering().SectionForGlobal(I, Mang, TM);
I->setSection(((const PIC16Section *)S)->getName());
}
}
DbgInfo.BeginModule(M);
EmitFunctionDecls(M);
EmitUndefinedVars(M);
EmitDefinedVars(M);
EmitIData(M);
EmitUData(M);
EmitRomData(M);
EmitSharedUdata(M);
EmitUserSections(M);
return Result;
}
void PIC16AsmPrinter::EmitFunctionDecls(Module &M) {
O <<"\n"<<MAI->getCommentString() << "Function Declarations - BEGIN." <<"\n";
for (Module::iterator I = M.begin(), E = M.end(); I != E; I++) {
if (I->isIntrinsic() || I->getName() == "@abort")
continue;
if (!I->isDeclaration() && !I->hasExternalLinkage())
continue;
MCSymbol *Sym = Mang->getSymbol(I);
if (I->isDeclaration() && PAN::isMemIntrinsic(Sym->getName())) continue;
const char *directive = I->isDeclaration() ? MAI->getExternDirective() :
MAI->getGlobalDirective();
O << directive << Sym->getName() << "\n";
O << directive << PAN::getRetvalLabel(Sym->getName()) << "\n";
O << directive << PAN::getArgsLabel(Sym->getName()) << "\n";
}
O << MAI->getCommentString() << "Function Declarations - END." <<"\n";
}
void PIC16AsmPrinter::EmitUndefinedVars(Module &M) {
std::vector<const GlobalVariable*> Items = ExternalVarDecls;
if (!Items.size()) return;
O << "\n" << MAI->getCommentString() << "Imported Variables - BEGIN" << "\n";
for (unsigned j = 0; j < Items.size(); j++)
O << MAI->getExternDirective() << *Mang->getSymbol(Items[j]) << "\n";
O << MAI->getCommentString() << "Imported Variables - END" << "\n";
}
void PIC16AsmPrinter::EmitDefinedVars(Module &M) {
std::vector<const GlobalVariable*> Items = ExternalVarDefs;
if (!Items.size()) return;
O << "\n" << MAI->getCommentString() << "Exported Variables - BEGIN" << "\n";
for (unsigned j = 0; j < Items.size(); j++)
O << MAI->getGlobalDirective() << *Mang->getSymbol(Items[j]) << "\n";
O << MAI->getCommentString() << "Exported Variables - END" << "\n";
}
void PIC16AsmPrinter::EmitRomData(Module &M) {
EmitSingleSection(PTOF->ROMDATASection());
}
void PIC16AsmPrinter::EmitSharedUdata(Module &M) {
EmitSingleSection(PTOF->SHAREDUDATASection());
}
bool PIC16AsmPrinter::doFinalization(Module &M) {
EmitAllAutos(M);
printLibcallDecls();
DbgInfo.EndModule(M);
O << "\n\t" << "END\n";
return AsmPrinter::doFinalization(M);
}
void PIC16AsmPrinter::EmitFunctionFrame(MachineFunction &MF) {
const Function *F = MF.getFunction();
const TargetData *TD = TM.getTargetData();
O << "\n";
PIC16Section *fPDataSection =
const_cast<PIC16Section *>(getObjFileLowering().
SectionForFrame(CurrentFnSym->getName()));
fPDataSection->setColor(getFunctionColor(F));
OutStreamer.SwitchSection(fPDataSection);
O << PAN::getFrameLabel(CurrentFnSym->getName()) << ":\n";
const Type *RetType = F->getReturnType();
unsigned RetSize = 0;
if (RetType->getTypeID() != Type::VoidTyID)
RetSize = TD->getTypeAllocSize(RetType);
if(RetSize > 0)
O << PAN::getRetvalLabel(CurrentFnSym->getName())
<< " RES " << RetSize << "\n";
else
O << PAN::getRetvalLabel(CurrentFnSym->getName()) << ": \n";
unsigned ArgSize = 0;
for (Function::const_arg_iterator argi = F->arg_begin(),
arge = F->arg_end(); argi != arge ; ++argi) {
const Type *Ty = argi->getType();
ArgSize += TD->getTypeAllocSize(Ty);
}
O << PAN::getArgsLabel(CurrentFnSym->getName()) << " RES " << ArgSize << "\n";
int TempSize = PTLI->GetTmpSize();
if (TempSize > 0)
O << PAN::getTempdataLabel(CurrentFnSym->getName()) << " RES "
<< TempSize << '\n';
}
void PIC16AsmPrinter::EmitInitializedDataSection(const PIC16Section *S) {
OutStreamer.SwitchSection(S);
std::vector<const GlobalVariable*> Items = S->Items;
for (unsigned j = 0; j < Items.size(); j++) {
Constant *C = Items[j]->getInitializer();
int AddrSpace = Items[j]->getType()->getAddressSpace();
O << *Mang->getSymbol(Items[j]);
EmitGlobalConstant(C, AddrSpace);
}
}
void PIC16AsmPrinter::EmitIData(Module &M) {
EmitSectionList (M, PTOF->IDATASections());
}
void PIC16AsmPrinter::
EmitUninitializedDataSection(const PIC16Section *S) {
const TargetData *TD = TM.getTargetData();
OutStreamer.SwitchSection(S);
std::vector<const GlobalVariable*> Items = S->Items;
for (unsigned j = 0; j < Items.size(); j++) {
Constant *C = Items[j]->getInitializer();
const Type *Ty = C->getType();
unsigned Size = TD->getTypeAllocSize(Ty);
O << *Mang->getSymbol(Items[j]) << " RES " << Size << "\n";
}
}
void PIC16AsmPrinter::EmitUData(Module &M) {
EmitSectionList (M, PTOF->UDATASections());
}
void PIC16AsmPrinter::EmitUserSections(Module &M) {
EmitSectionList (M, PTOF->USERSections());
}
void PIC16AsmPrinter::EmitAllAutos(Module &M) {
EmitSectionList (M, PTOF->AUTOSections());
}
extern "C" void LLVMInitializePIC16AsmPrinter() {
RegisterAsmPrinter<PIC16AsmPrinter> X(ThePIC16Target);
}
void PIC16AsmPrinter::EmitSingleSection(const PIC16Section *S) {
if (S == NULL) return;
switch (S->getType()) {
default: llvm_unreachable ("unknow user section type");
case UDATA:
case UDATA_SHR:
case UDATA_OVR:
EmitUninitializedDataSection(S);
break;
case IDATA:
case ROMDATA:
EmitInitializedDataSection(S);
break;
}
}
void PIC16AsmPrinter::
EmitSectionList(Module &M, const std::vector<PIC16Section *> &SList) {
for (unsigned i = 0; i < SList.size(); i++) {
if (SList[i]->getName().find("llvm.") != std::string::npos)
continue;
O << "\n";
EmitSingleSection(SList[i]);
}
}