mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-09-03 02:30:00 +00:00
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@108130 91177308-0d34-0410-b5e6-96231b3b80d8
255 lines
8.5 KiB
C++
255 lines
8.5 KiB
C++
//===-- PIC16MemSelOpt.cpp - PIC16 banksel optimizer --------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the pass which optimizes the emitting of banksel
|
|
// instructions before accessing data memory. This currently works within
|
|
// a basic block only and keep tracks of the last accessed memory bank.
|
|
// If memory access continues to be in the same bank it just makes banksel
|
|
// immediate, which is a part of the insn accessing the data memory, from 1
|
|
// to zero. The asm printer emits a banksel only if that immediate is 1.
|
|
//
|
|
// FIXME: this is not implemented yet. The banksel pass only works on local
|
|
// basic blocks.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#define DEBUG_TYPE "pic16-codegen"
|
|
#include "PIC16.h"
|
|
#include "PIC16ABINames.h"
|
|
#include "PIC16InstrInfo.h"
|
|
#include "PIC16MCAsmInfo.h"
|
|
#include "PIC16TargetMachine.h"
|
|
#include "llvm/CodeGen/MachineFunctionPass.h"
|
|
#include "llvm/CodeGen/MachineInstrBuilder.h"
|
|
#include "llvm/CodeGen/Passes.h"
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
|
#include "llvm/Target/TargetMachine.h"
|
|
#include "llvm/GlobalValue.h"
|
|
#include "llvm/DerivedTypes.h"
|
|
|
|
using namespace llvm;
|
|
|
|
namespace {
|
|
struct MemSelOpt : public MachineFunctionPass {
|
|
static char ID;
|
|
MemSelOpt() : MachineFunctionPass(&ID) {}
|
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
AU.addPreservedID(MachineLoopInfoID);
|
|
AU.addPreservedID(MachineDominatorsID);
|
|
MachineFunctionPass::getAnalysisUsage(AU);
|
|
}
|
|
|
|
virtual bool runOnMachineFunction(MachineFunction &MF);
|
|
|
|
virtual const char *getPassName() const {
|
|
return "PIC16 Memsel Optimizer";
|
|
}
|
|
|
|
bool processBasicBlock(MachineFunction &MF, MachineBasicBlock &MBB);
|
|
bool processInstruction(MachineInstr *MI);
|
|
|
|
private:
|
|
const TargetInstrInfo *TII; // Machine instruction info.
|
|
MachineBasicBlock *MBB; // Current basic block
|
|
std::string CurBank;
|
|
int PageChanged;
|
|
|
|
};
|
|
char MemSelOpt::ID = 0;
|
|
}
|
|
|
|
FunctionPass *llvm::createPIC16MemSelOptimizerPass() {
|
|
return new MemSelOpt();
|
|
}
|
|
|
|
|
|
/// runOnMachineFunction - Loop over all of the basic blocks, transforming FP
|
|
/// register references into FP stack references.
|
|
///
|
|
bool MemSelOpt::runOnMachineFunction(MachineFunction &MF) {
|
|
TII = MF.getTarget().getInstrInfo();
|
|
bool Changed = false;
|
|
for (MachineFunction::iterator I = MF.begin(), E = MF.end();
|
|
I != E; ++I) {
|
|
Changed |= processBasicBlock(MF, *I);
|
|
}
|
|
|
|
return Changed;
|
|
}
|
|
|
|
/// processBasicBlock - Loop over all of the instructions in the basic block,
|
|
/// transforming FP instructions into their stack form.
|
|
///
|
|
bool MemSelOpt::processBasicBlock(MachineFunction &MF, MachineBasicBlock &BB) {
|
|
bool Changed = false;
|
|
MBB = &BB;
|
|
|
|
// Let us assume that when entering a basic block now bank is selected.
|
|
// Ideally we should look at the predecessors for this information.
|
|
CurBank="";
|
|
PageChanged=0;
|
|
|
|
MachineBasicBlock::iterator I;
|
|
for (I = BB.begin(); I != BB.end(); ++I) {
|
|
Changed |= processInstruction(I);
|
|
|
|
// if the page has changed insert a page sel before
|
|
// any instruction that needs one
|
|
if (PageChanged == 1)
|
|
{
|
|
// Restore the page if it was changed, before leaving the basic block,
|
|
// because it may be required by the goto terminator or the fall thru
|
|
// basic blcok.
|
|
// If the terminator is return, we don't need to restore since there
|
|
// is no goto or fall thru basic block.
|
|
if ((I->getOpcode() == PIC16::sublw_3) || //macro has goto
|
|
(I->getOpcode() == PIC16::sublw_6) || //macro has goto
|
|
(I->getOpcode() == PIC16::addlwc) || //macro has goto
|
|
(TII->get(I->getOpcode()).isBranch()))
|
|
{
|
|
DebugLoc dl = I->getDebugLoc();
|
|
BuildMI(*MBB, I, dl, TII->get(PIC16::pagesel)).addExternalSymbol("$");
|
|
Changed = true;
|
|
PageChanged = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// The basic block is over, but if we did not find any goto yet,
|
|
// we haven't restored the page.
|
|
// Restore the page if it was changed, before leaving the basic block,
|
|
// because it may be required by fall thru basic blcok.
|
|
// If the terminator is return, we don't need to restore since there
|
|
// is fall thru basic block.
|
|
if (PageChanged == 1) {
|
|
// save the end pointer before we move back to last insn.
|
|
MachineBasicBlock::iterator J = I;
|
|
I--;
|
|
const TargetInstrDesc &TID = TII->get(I->getOpcode());
|
|
if (! TID.isReturn())
|
|
{
|
|
DebugLoc dl = I->getDebugLoc();
|
|
BuildMI(*MBB, J, dl,
|
|
TII->get(PIC16::pagesel)).addExternalSymbol("$");
|
|
Changed = true;
|
|
PageChanged = 0;
|
|
}
|
|
}
|
|
|
|
|
|
return Changed;
|
|
}
|
|
|
|
bool MemSelOpt::processInstruction(MachineInstr *MI) {
|
|
bool Changed = false;
|
|
|
|
unsigned NumOperands = MI->getNumOperands();
|
|
if (NumOperands == 0) return false;
|
|
|
|
|
|
// If this insn is not going to access any memory, return.
|
|
const TargetInstrDesc &TID = TII->get(MI->getOpcode());
|
|
if (!(TID.isBranch() || TID.isCall() || TID.mayLoad() || TID.mayStore()))
|
|
return false;
|
|
|
|
// The first thing we should do is that record if banksel/pagesel are
|
|
// changed in an unknown way. This can happend via any type of call.
|
|
// We do it here first before scanning of MemOp / BBOp as the indirect
|
|
// call insns do not have any operands, but they still may change bank/page.
|
|
if (TID.isCall()) {
|
|
// Record that we have changed the page, so that we can restore it
|
|
// before basic block ends.
|
|
// We require to signal that a page anc bank change happened even for
|
|
// indirect calls.
|
|
PageChanged = 1;
|
|
|
|
// When a call is made, there may be banksel for variables in callee.
|
|
// Hence the banksel in caller needs to be reset.
|
|
CurBank = "";
|
|
}
|
|
|
|
// Scan for the memory address operand.
|
|
// FIXME: Should we use standard interfaces like memoperands_iterator,
|
|
// hasMemOperand() etc ?
|
|
int MemOpPos = -1;
|
|
int BBOpPos = -1;
|
|
for (unsigned i = 0; i < NumOperands; i++) {
|
|
MachineOperand Op = MI->getOperand(i);
|
|
if (Op.getType() == MachineOperand::MO_GlobalAddress ||
|
|
Op.getType() == MachineOperand::MO_ExternalSymbol) {
|
|
// We found one mem operand. Next one may be BS.
|
|
MemOpPos = i;
|
|
}
|
|
if (Op.getType() == MachineOperand::MO_MachineBasicBlock) {
|
|
// We found one BB operand. Next one may be pagesel.
|
|
BBOpPos = i;
|
|
}
|
|
}
|
|
|
|
// If we did not find an insn accessing memory. Continue.
|
|
if ((MemOpPos == -1) &&
|
|
(BBOpPos == -1))
|
|
return false;
|
|
assert ((BBOpPos != MemOpPos) && "operand can only be of one type");
|
|
|
|
|
|
// If this is a pagesel material, handle it first.
|
|
// CALL and br_ucond insns use MemOp (GA or ES) and not BBOp.
|
|
// Pagesel is required only for a direct call.
|
|
if ((MI->getOpcode() == PIC16::CALL)) {
|
|
// Get the BBOp.
|
|
MachineOperand &MemOp = MI->getOperand(MemOpPos);
|
|
DebugLoc dl = MI->getDebugLoc();
|
|
BuildMI(*MBB, MI, dl, TII->get(PIC16::pagesel)).addOperand(MemOp);
|
|
|
|
// CALL and br_ucond needs only pagesel. so we are done.
|
|
return true;
|
|
}
|
|
|
|
// Pagesel is handled. Now, add a Banksel if needed.
|
|
if (MemOpPos == -1) return Changed;
|
|
// Get the MemOp.
|
|
MachineOperand &Op = MI->getOperand(MemOpPos);
|
|
|
|
// Get the section name(NewBank) for MemOp.
|
|
// This assumes that the section names for globals are already set by
|
|
// AsmPrinter->doInitialization.
|
|
std::string NewBank = CurBank;
|
|
bool hasExternalLinkage = false;
|
|
if (Op.getType() == MachineOperand::MO_GlobalAddress &&
|
|
Op.getGlobal()->getType()->getAddressSpace() == PIC16ISD::RAM_SPACE) {
|
|
if (Op.getGlobal()->hasExternalLinkage())
|
|
hasExternalLinkage= true;
|
|
NewBank = Op.getGlobal()->getSection();
|
|
} else if (Op.getType() == MachineOperand::MO_ExternalSymbol) {
|
|
// External Symbol is generated for temp data and arguments. They are
|
|
// in fpdata.<functionname>.# section.
|
|
std::string Sym = Op.getSymbolName();
|
|
NewBank = PAN::getSectionNameForSym(Sym);
|
|
}
|
|
|
|
// If the section is shared section, do not emit banksel.
|
|
if (NewBank == PAN::getSharedUDataSectionName())
|
|
return Changed;
|
|
|
|
// If the previous and new section names are same, we don't need to
|
|
// emit banksel.
|
|
if (NewBank.compare(CurBank) != 0 || hasExternalLinkage) {
|
|
DebugLoc dl = MI->getDebugLoc();
|
|
BuildMI(*MBB, MI, dl, TII->get(PIC16::banksel)).
|
|
addOperand(Op);
|
|
Changed = true;
|
|
CurBank = NewBank;
|
|
}
|
|
|
|
return Changed;
|
|
}
|
|
|