DbgInfo.BeginFunction(MF);
// Emit the autos section of function.
- EmitAutos(CurrentFnName);
+ EmitAutos(F);
// Now emit the instructions of function in its code section.
const MCSection *fCodeSection =
const TargetData *TD = TM.getTargetData();
// Emit the data section name.
O << "\n";
-
+
+ std::string SectionName = getObjFileLowering().getNameForFunctFrame(F);
const MCSection *fPDataSection =
- getObjFileLowering().getSectionForFunctionFrame(CurrentFnName);
+ getObjFileLowering().getSectionForFunctionFrame(SectionName);
OutStreamer.SwitchSection(fPDataSection);
// Emit function frame label
}
}
-void PIC16AsmPrinter::EmitAutos(std::string FunctName) {
+void PIC16AsmPrinter::EmitAutos(const Function *F) {
// 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::string SectionName = PAN::getAutosSectionName(CurrentFnName);
// If this function is a cloned function then the name of auto section
// will not be present in the list of existing section. Hence this section
if (AutosSections[i]->S_->getName() == SectionName) {
// Set the printing status to true
AutosSections[i]->setPrintedStatus(true);
+ // Overlay auto sections with same function color.
+ std::string BaseSectionName = getObjFileLowering().
+ getNameForFunctFrame(F, true);
+ if (BaseSectionName != F->getName()) {
+ std::string NewSectionName = PAN::getAutosSectionName(BaseSectionName);
+ const_cast<MCSectionPIC16 *>(AutosSections[i]->S_)->setName(
+ NewSectionName);
+ }
+
OutStreamer.SwitchSection(AutosSections[i]->S_);
const std::vector<const GlobalVariable*> &Items = AutosSections[i]->Items;
for (unsigned j = 0; j < Items.size(); j++) {
void EmitDefinedVars (Module &M);
void EmitIData (Module &M);
void EmitUData (Module &M);
- void EmitAutos (std::string FunctName);
+ void EmitAutos (const Function *F);
void EmitRemainingAutos ();
void EmitRomData (Module &M);
void EmitFunctionFrame(MachineFunction &MF);
public:
const std::string &getName() const { return Name; }
-
+
+ void setName(std::string name) { Name = name; }
static MCSectionPIC16 *Create(const StringRef &Name,
SectionKind K, MCContext &Ctx);
UGE
};
}
+
// External symbol names require memory to live till the program end.
// So we have to allocate it and keep.
inline static const char *createESName (const std::string &name) {
#include <cassert>
#include <cstring>
#include <string>
-
namespace llvm {
+namespace PIC16Overlay {
+ // Implement Overlay through colors because we may want to enhance overlay
+ // architecture later. More colors can be added then.
+ // Idea here is that functions with same color can be overlayed.
+ enum Overlay {
+ // A color name can only consist of upper case letters and underscore.
+ GREEN, // Stands for mainline functions that can be overlayed.
+ GREEN_IL, // Interrupt line version of GREEN.
+ RED // Stands for functions that can not be overlayed.
+ };
+}
+
// A Central class to manage all ABI naming conventions.
// PAN - [P]ic16 [A]BI [N]ames
class PAN {
}
}
}
+ inline static std::string getOverlayStr(unsigned Color) {
+ std::string Str = "Overlay=";
+ Str.append(getSectionNameForColor(Color));
+ return Str;
+ }
+
+ inline static std::string getSectionNameForColor(unsigned Color) {
+ switch (Color) {
+ case PIC16Overlay::GREEN:
+ return "GREEN";
+ case PIC16Overlay::GREEN_IL:
+ return "GREEN_IL";
+ default:
+ assert( 0 && "Color not supported");
+ }
+ }
+
+ inline static std::string getAutosSectionForColor(std::string Color) {
+ return Color.append("_AUTOS");
+ }
+
}; // class PAN.
} // end namespace llvm;
LOADABLE_MODULE = 1
+# Hack: we need to include 'main' pic16 target directory to grab private headers
+CPPFLAGS = -I$(PROJ_OBJ_DIR)/.. -I$(PROJ_SRC_DIR)/..
+
include $(LEVEL)/Makefile.common
--- /dev/null
+//===-- PIC16FrameOverlay.cpp - Implementation for PIC16 Frame Overlay===//
+//
+// 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 PIC16 Frame Overlay implementation.
+//
+//===----------------------------------------------------------------------===//
+
+
+#include "llvm/Analysis/CallGraph.h"
+#include "llvm/Pass.h"
+#include "llvm/Module.h"
+#include "llvm/Support/raw_ostream.h"
+#include "PIC16.h"
+#include "PIC16FrameOverlay.h"
+#include <vector>
+#include <iostream>
+using namespace llvm;
+using std::vector;
+using std::string;
+
+
+void PIC16FrameOverlay::getAnalysisUsage(AnalysisUsage &AU) const {
+ AU.setPreservesCFG();
+ AU.addRequired<CallGraph>();
+}
+
+bool PIC16FrameOverlay::runOnModule(Module &M) {
+ CallGraph &CG = getAnalysis<CallGraph>();
+ for (CallGraph::iterator it = CG.begin() ; it != CG.end(); it++)
+ {
+ // External calling node doesn't have any function associated
+ // with it
+ if (!it->first)
+ continue;
+
+ if (it->second->size() == 0) {
+ if (PAN::isInterruptLineFunction(it->first))
+ ColorFunction(it->second, PIC16Overlay::GREEN_IL);
+ else
+ ColorFunction(it->second, PIC16Overlay::GREEN);
+ }
+ }
+ return false;
+}
+
+void PIC16FrameOverlay::ColorFunction(CallGraphNode *CGN, unsigned Color) {
+ switch (Color) {
+ case PIC16Overlay::GREEN:
+ case PIC16Overlay::GREEN_IL: {
+ Function *LeafFunct = CGN->getFunction();
+ std::string Section = "";
+ if (LeafFunct->hasSection()) {
+ Section = LeafFunct->getSection();
+ Section.append(" ");
+ }
+ Section.append(PAN::getOverlayStr(Color));
+ LeafFunct->setSection(Section);
+ break;
+ }
+ default:
+ assert( 0 && "Color not supported");
+ }
+}
--- /dev/null
+//===-- PIC16FrameOverlay.h - Interface for PIC16 Frame Overlay -*- 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 PIC16 Frame Overlay infrastructure.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef PIC16FRAMEOVERLAY_H
+#define PIC16FRAMEOVERLAY_H
+
+#include "llvm/Analysis/CallGraph.h"
+#include "llvm/Pass.h"
+#include "llvm/Module.h"
+#include "llvm/Support/raw_ostream.h"
+#include <vector>
+#include <iostream>
+using std::vector;
+using std::string;
+using namespace llvm;
+
+namespace {
+
+ class PIC16FrameOverlay : public ModulePass {
+ public:
+ static char ID; // Class identification
+ PIC16FrameOverlay() : ModulePass(&ID) {}
+
+ virtual void getAnalysisUsage(AnalysisUsage &AU) const;
+ virtual bool runOnModule(Module &M);
+ private:
+ void ColorFunction(CallGraphNode *CGN, unsigned Color);
+ };
+ char PIC16FrameOverlay::ID = 0;
+ static RegisterPass<PIC16FrameOverlay>
+ Y("pic16overlay", "PIC16 Frame Overlay Analysis");
+
+} // End of namespace
+
+#endif
return getPIC16Section(T.c_str(), SectionKind::getDataRel());
}
+std::string PIC16TargetObjectFile::getNameForFunctFrame(const Function *F,
+ bool IsAutosSection) {
+ std::string SectionName = F->getName();
+ if (F->hasSection()) {
+ std::string Sectn = F->getSection();
+ std::string StrToFind = "Overlay=";
+ unsigned Pos = Sectn.find(StrToFind);
+ if (Pos != std::string::npos) {
+ Pos += StrToFind.length();
+ std::string Color = "";
+ char c = Sectn.at(Pos);
+ // A Color can only consist on upper case letters or underscore.
+ while ((c >= 'A' && c<= 'Z') || c == '_') {
+ Color.append(1,c);
+ Pos++;
+ if (Pos >= Sectn.length())
+ break;
+ c = Sectn.at(Pos);
+ }
+ // Autos Section need to be given a different name from function frame.
+ if (IsAutosSection)
+ SectionName = PAN::getAutosSectionForColor(Color);
+ else
+ SectionName = Color;
+ }
+ }
+ return SectionName;
+}
+
const MCSection *
PIC16TargetObjectFile::getBSSSectionForGlobal(const GlobalVariable *GV) const {
assert(GV->hasInitializer() && "This global doesn't need space");
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/ADT/StringMap.h"
+#include "llvm/Function.h"
#include <vector>
#include <string>
// If the current function is cloned then create the new autos section
// also.
void createClonedSectionForAutos(const std::string &SecName);
+ std::string getNameForFunctFrame(const Function *F,
+ bool IsAutosSection = false);
+
private:
std::string getSectionNameForSym(const std::string &Sym) const;
projects / oota-llvm.git / commitdiff