#include "llvm/Module.h"
#include "llvm/CodeGen/DwarfWriter.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
-#include "llvm/Support/raw_ostream.h"
-#include "llvm/Support/Mangler.h"
-#include "llvm/Support/ErrorHandling.h"
#include "llvm/CodeGen/DwarfWriter.h"
#include "llvm/CodeGen/MachineModuleInfo.h"
-
+#include "llvm/MC/MCSection.h"
+#include "llvm/Target/TargetRegistry.h"
+#include "llvm/Target/TargetLoweringObjectFile.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/FormattedStream.h"
+#include "llvm/Support/Mangler.h"
using namespace llvm;
#include "PIC16GenAsmWriter.inc"
+PIC16AsmPrinter::PIC16AsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
+ const TargetAsmInfo *T, bool V)
+: AsmPrinter(O, TM, T, V), DbgInfo(O, T) {
+ PTLI = static_cast<const PIC16TargetLowering*>(TM.getTargetLowering());
+ PTAI = static_cast<const PIC16TargetAsmInfo*>(T);
+ PTOF = (PIC16TargetObjectFile*)&PTLI->getObjFileLowering();
+}
+
bool PIC16AsmPrinter::printMachineInstruction(const MachineInstr *MI) {
printInstruction(MI);
return true;
EmitAutos(CurrentFnName);
// Now emit the instructions of function in its code section.
- const char *codeSection = PAN::getCodeSectionName(CurrentFnName).c_str();
+ std::string T = PAN::getCodeSectionName(CurrentFnName);
+ const char *codeSection = T.c_str();
- const Section *fCodeSection = TAI->getNamedSection(codeSection,
- SectionFlags::Code);
+ const MCSection *fCodeSection =
+ getObjFileLowering().getOrCreateSection(codeSection, false,
+ SectionKind::getText());
// Start the Code Section.
O << "\n";
- SwitchToSection (fCodeSection);
+ SwitchToSection(fCodeSection);
// Emit the frame address of the function at the beginning of code.
O << "\tretlw low(" << PAN::getFrameLabel(CurrentFnName) << ")\n";
return false; // we didn't modify anything.
}
-/// createPIC16CodePrinterPass - Returns a pass that prints the PIC16
-/// assembly code for a MachineFunction to the given output stream,
-/// using the given target machine description. This should work
-/// regardless of whether the function is in SSA form.
-///
-FunctionPass *llvm::createPIC16CodePrinterPass(raw_ostream &o,
- PIC16TargetMachine &tm,
- bool verbose) {
- return new PIC16AsmPrinter(o, tm, tm.getTargetAsmInfo(), verbose);
-}
-
// printOperand - print operand of insn.
void PIC16AsmPrinter::printOperand(const MachineInstr *MI, int opNum) {
return;
case MachineOperand::MO_GlobalAddress: {
- O << Mang->getMangledName(MO.getGlobal());
+ std::string Sname = Mang->getMangledName(MO.getGlobal());
+ // FIXME: currently we do not have a memcpy def coming in the module
+ // by any chance, as we do not link in those as .bc lib. So these calls
+ // are always external and it is safe to emit an extern.
+ if (PAN::isMemIntrinsic(Sname)) {
+ LibcallDecls.push_back(createESName(Sname));
+ }
+
+ O << Sname;
break;
}
case MachineOperand::MO_ExternalSymbol: {
LibcallDecls.push_back(Sname);
}
- O << Sname;
+ // Record a call to intrinsic to print the extern declaration for it.
+ std::string Sym = Sname;
+ if (PAN::isMemIntrinsic(Sym)) {
+ Sym = PAN::addPrefix(Sym);
+ LibcallDecls.push_back(createESName(Sym));
+ }
+
+ O << Sym;
break;
}
case MachineOperand::MO_MachineBasicBlock:
O << PIC16CondCodeToString((PIC16CC::CondCodes)CC);
}
+// This function is used to sort the decls list.
+// should return true if s1 should come before s2.
+static bool is_before(const char *s1, const char *s2) {
+ std::string str1 = s1;
+ std::string str2 = s2;
+ int i = str1.compare(str2);
+ // Return true if s1 is smaller or equal.
+ if (i <= 0) return true;
+ // false if s1 should come after s2.
+ return false;
+}
+
+// This is used by list::unique below.
+// unique will filter out duplicates if it knows them.
+static bool is_duplicate(const char *s1, const char *s2) {
+ std::string str1 = s1;
+ std::string str2 = s2;
+ return str1 == str2;
+}
+
/// printLibcallDecls - print the extern declarations for compiler
/// intrinsics.
///
O << TAI->getCommentString() << "External decls for libcalls - BEGIN." <<"\n";
// Remove duplicate entries.
- LibcallDecls.sort();
- LibcallDecls.unique();
+ LibcallDecls.sort(is_before);
+ LibcallDecls.unique(is_duplicate);
+
for (std::list<const char*>::const_iterator I = LibcallDecls.begin();
I != LibcallDecls.end(); I++) {
O << TAI->getExternDirective() << *I << "\n";
/// One task that we do here is to sectionize all global variables.
/// The MemSelOptimizer pass depends on the sectionizing.
///
-bool PIC16AsmPrinter::doInitialization (Module &M) {
+bool PIC16AsmPrinter::doInitialization(Module &M) {
bool Result = AsmPrinter::doInitialization(M);
// FIXME:: This is temporary solution to generate the include file.
// Set the section names for all globals.
for (Module::global_iterator I = M.global_begin(), E = M.global_end();
- I != E; ++I) {
- I->setSection(TAI->SectionForGlobal(I)->getName());
- }
+ I != E; ++I)
+ if (!I->isDeclaration() && !I->hasAvailableExternallyLinkage())
+ I->setSection(getObjFileLowering().
+ SectionForGlobal(I, Mang,TM)->getName());
DbgInfo.BeginModule(M);
EmitFunctionDecls(M);
/// global declarations for function defined in this module and which are
/// available to other modules.
///
-void PIC16AsmPrinter::EmitFunctionDecls (Module &M) {
+void PIC16AsmPrinter::EmitFunctionDecls(Module &M) {
// Emit declarations for external functions.
O <<"\n"<<TAI->getCommentString() << "Function Declarations - BEGIN." <<"\n";
for (Module::iterator I = M.begin(), E = M.end(); I != E; I++) {
+ if (I->isIntrinsic())
+ continue;
+
std::string Name = Mang->getMangledName(I);
if (Name.compare("@abort") == 0)
continue;
- // If it is llvm intrinsic call then don't emit
- if (Name.find("llvm.") != std::string::npos)
+ if (!I->isDeclaration() && !I->hasExternalLinkage())
continue;
- if (! (I->isDeclaration() || I->hasExternalLinkage()))
- continue;
+ // Do not emit memcpy, memset, and memmove here.
+ // Calls to these routines can be generated in two ways,
+ // 1. User calling the standard lib function
+ // 2. Codegen generating these calls for llvm intrinsics.
+ // In the first case a prototype is alread availale, while in
+ // second case the call is via and externalsym and the prototype is missing.
+ // So declarations for these are currently always getting printing by
+ // tracking both kind of references in printInstrunction.
+ if (I->isDeclaration() && PAN::isMemIntrinsic(Name)) continue;
const char *directive = I->isDeclaration() ? TAI->getExternDirective() :
TAI->getGlobalDirective();
}
// Emit variables imported from other Modules.
-void PIC16AsmPrinter::EmitUndefinedVars (Module &M)
-{
- std::vector<const GlobalVariable*> Items = PTAI->ExternalVarDecls->Items;
- if (! Items.size()) return;
+void PIC16AsmPrinter::EmitUndefinedVars(Module &M) {
+ std::vector<const GlobalVariable*> Items = PTOF->ExternalVarDecls->Items;
+ if (!Items.size()) return;
O << "\n" << TAI->getCommentString() << "Imported Variables - BEGIN" << "\n";
for (unsigned j = 0; j < Items.size(); j++) {
}
// Emit variables defined in this module and are available to other modules.
-void PIC16AsmPrinter::EmitDefinedVars (Module &M)
-{
- std::vector<const GlobalVariable*> Items = PTAI->ExternalVarDefs->Items;
- if (! Items.size()) return;
+void PIC16AsmPrinter::EmitDefinedVars(Module &M) {
+ std::vector<const GlobalVariable*> Items = PTOF->ExternalVarDefs->Items;
+ if (!Items.size()) return;
- O << "\n" << TAI->getCommentString() << "Exported Variables - BEGIN" << "\n";
+ O << "\n" << TAI->getCommentString() << "Exported Variables - BEGIN" << "\n";
for (unsigned j = 0; j < Items.size(); j++) {
O << TAI->getGlobalDirective() << Mang->getMangledName(Items[j]) << "\n";
}
}
// Emit initialized data placed in ROM.
-void PIC16AsmPrinter::EmitRomData (Module &M)
-{
+void PIC16AsmPrinter::EmitRomData(Module &M) {
// Print ROM Data section.
- std::vector <PIC16Section *>ROSections = PTAI->ROSections;
+ const std::vector<PIC16Section*> &ROSections = PTOF->ROSections;
for (unsigned i = 0; i < ROSections.size(); i++) {
- std::vector<const GlobalVariable*> Items = ROSections[i]->Items;
- if (! Items.size()) continue;
+ const std::vector<const GlobalVariable*> &Items = ROSections[i]->Items;
+ if (!Items.size()) continue;
O << "\n";
- SwitchToSection(PTAI->ROSections[i]->S_);
+ SwitchToSection(PTOF->ROSections[i]->S_);
for (unsigned j = 0; j < Items.size(); j++) {
O << Mang->getMangledName(Items[j]);
Constant *C = Items[j]->getInitializer();
EmitRemainingAutos();
DbgInfo.EndModule(M);
O << "\n\t" << "END\n";
- bool Result = AsmPrinter::doFinalization(M);
- return Result;
+ return AsmPrinter::doFinalization(M);
}
void PIC16AsmPrinter::EmitFunctionFrame(MachineFunction &MF) {
const TargetData *TD = TM.getTargetData();
// Emit the data section name.
O << "\n";
- const char *SectionName = PAN::getFrameSectionName(CurrentFnName).c_str();
+ std::string T = PAN::getFrameSectionName(CurrentFnName);
+ const char *SectionName = T.c_str();
- const Section *fPDataSection = TAI->getNamedSection(SectionName,
- SectionFlags::Writeable);
+ const MCSection *fPDataSection =
+ getObjFileLowering().getOrCreateSection(SectionName, false,
+ SectionKind::getDataRel());
SwitchToSection(fPDataSection);
// Emit function frame label
// Emit temporary space
int TempSize = PTLI->GetTmpSize();
- if (TempSize > 0 )
- O << PAN::getTempdataLabel(CurrentFnName) << " RES " << TempSize <<"\n";
+ if (TempSize > 0)
+ O << PAN::getTempdataLabel(CurrentFnName) << " RES " << TempSize << '\n';
}
-void PIC16AsmPrinter::EmitIData (Module &M) {
+void PIC16AsmPrinter::EmitIData(Module &M) {
// Print all IDATA sections.
- std::vector <PIC16Section *>IDATASections = PTAI->IDATASections;
+ const std::vector<PIC16Section*> &IDATASections = PTOF->IDATASections;
for (unsigned i = 0; i < IDATASections.size(); i++) {
O << "\n";
if (IDATASections[i]->S_->getName().find("llvm.") != std::string::npos)
}
}
-void PIC16AsmPrinter::EmitUData (Module &M) {
+void PIC16AsmPrinter::EmitUData(Module &M) {
const TargetData *TD = TM.getTargetData();
// Print all BSS sections.
- std::vector <PIC16Section *>BSSSections = PTAI->BSSSections;
+ const std::vector<PIC16Section*> &BSSSections = PTOF->BSSSections;
for (unsigned i = 0; i < BSSSections.size(); i++) {
O << "\n";
SwitchToSection(BSSSections[i]->S_);
const Type *Ty = C->getType();
unsigned Size = TD->getTypeAllocSize(Ty);
- O << Name << " " <<"RES"<< " " << Size ;
- O << "\n";
+ O << Name << " RES " << Size << "\n";
}
}
}
-void PIC16AsmPrinter::EmitAutos (std::string FunctName)
-{
+void PIC16AsmPrinter::EmitAutos(std::string FunctName) {
// Section names for all globals are already set.
-
const TargetData *TD = TM.getTargetData();
// Now print Autos section for this function.
std::string SectionName = PAN::getAutosSectionName(FunctName);
- std::vector <PIC16Section *>AutosSections = PTAI->AutosSections;
+ const std::vector<PIC16Section*> &AutosSections = PTOF->AutosSections;
for (unsigned i = 0; i < AutosSections.size(); i++) {
O << "\n";
if (AutosSections[i]->S_->getName() == SectionName) {
// Set the printing status to true
AutosSections[i]->setPrintedStatus(true);
SwitchToSection(AutosSections[i]->S_);
- std::vector<const GlobalVariable*> Items = AutosSections[i]->Items;
+ const std::vector<const GlobalVariable*> &Items = AutosSections[i]->Items;
for (unsigned j = 0; j < Items.size(); j++) {
std::string VarName = Mang->getMangledName(Items[j]);
Constant *C = Items[j]->getInitializer();
// Print autos that were not printed during the code printing of functions.
// As the functions might themselves would have got deleted by the optimizer.
-void PIC16AsmPrinter::EmitRemainingAutos()
-{
+void PIC16AsmPrinter::EmitRemainingAutos() {
const TargetData *TD = TM.getTargetData();
// Now print Autos section for this function.
- std::vector <PIC16Section *>AutosSections = PTAI->AutosSections;
+ std::vector <PIC16Section *>AutosSections = PTOF->AutosSections;
for (unsigned i = 0; i < AutosSections.size(); i++) {
// if the section is already printed then don't print again
O << "\n";
SwitchToSection(AutosSections[i]->S_);
- std::vector<const GlobalVariable*> Items = AutosSections[i]->Items;
+ const std::vector<const GlobalVariable*> &Items = AutosSections[i]->Items;
for (unsigned j = 0; j < Items.size(); j++) {
std::string VarName = Mang->getMangledName(Items[j]);
Constant *C = Items[j]->getInitializer();
}
}
+
+extern "C" void LLVMInitializePIC16Target() {
+ // Register the targets
+ RegisterTargetMachine<PIC16TargetMachine> A(ThePIC16Target);
+ RegisterTargetMachine<CooperTargetMachine> B(TheCooperTarget);
+ RegisterAsmPrinter<PIC16AsmPrinter> C(ThePIC16Target);
+ RegisterAsmPrinter<PIC16AsmPrinter> D(TheCooperTarget);
+}
projects / oota-llvm.git / blobdiff