mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-10-31 09:11:13 +00:00
38aa542f36
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@7651 91177308-0d34-0410-b5e6-96231b3b80d8
83 lines
2.8 KiB
C++
83 lines
2.8 KiB
C++
//===- InstrInfoEmitter.cpp - Generate a Instruction Set Desc. ------------===//
|
|
//
|
|
// This tablegen backend is responsible for emitting a description of the target
|
|
// instruction set for the code generator.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "InstrSelectorEmitter.h"
|
|
#include "Record.h"
|
|
|
|
NodeType::ArgResultTypes NodeType::Translate(Record *R) {
|
|
const std::string &Name = R->getName();
|
|
if (Name == "DNVT_void") return Void;
|
|
if (Name == "DNVT_val" ) return Val;
|
|
if (Name == "DNVT_arg0") return Arg0;
|
|
if (Name == "DNVT_ptr" ) return Ptr;
|
|
throw "Unknown DagNodeValType '" + Name + "'!";
|
|
}
|
|
|
|
|
|
/// ProcessNodeTypes - Process all of the node types in the current
|
|
/// RecordKeeper, turning them into the more accessible NodeTypes data
|
|
/// structure.
|
|
///
|
|
void InstrSelectorEmitter::ProcessNodeTypes() {
|
|
std::vector<Record*> Nodes = Records.getAllDerivedDefinitions("DagNode");
|
|
for (unsigned i = 0, e = Nodes.size(); i != e; ++i) {
|
|
Record *Node = Nodes[i];
|
|
|
|
// Translate the return type...
|
|
NodeType::ArgResultTypes RetTy =
|
|
NodeType::Translate(Node->getValueAsDef("RetType"));
|
|
|
|
// Translate the arguments...
|
|
ListInit *Args = Node->getValueAsListInit("ArgTypes");
|
|
std::vector<NodeType::ArgResultTypes> ArgTypes;
|
|
|
|
for (unsigned a = 0, e = Args->getSize(); a != e; ++a) {
|
|
if (DefInit *DI = dynamic_cast<DefInit*>(Args->getElement(a)))
|
|
ArgTypes.push_back(NodeType::Translate(DI->getDef()));
|
|
else
|
|
throw "In node " + Node->getName() + ", argument is not a Def!";
|
|
|
|
if (a == 0 && ArgTypes.back() == NodeType::Arg0)
|
|
throw "In node " + Node->getName() + ", arg 0 cannot have type 'arg0'!";
|
|
if (ArgTypes.back() == NodeType::Void)
|
|
throw "In node " + Node->getName() + ", args cannot be void type!";
|
|
}
|
|
if (RetTy == NodeType::Arg0 && Args->getSize() == 0)
|
|
throw "In node " + Node->getName() +
|
|
", invalid return type for nullary node!";
|
|
|
|
// Add the node type mapping now...
|
|
NodeTypes[Node] = NodeType(RetTy, ArgTypes);
|
|
}
|
|
}
|
|
|
|
/// ProcessInstructionPatterns - Read in all subclasses of Instruction, and
|
|
/// process those with a useful Pattern field.
|
|
///
|
|
void InstrSelectorEmitter::ProcessInstructionPatterns() {
|
|
std::vector<Record*> Insts = Records.getAllDerivedDefinitions("Instruction");
|
|
for (unsigned i = 0, e = Insts.size(); i != e; ++i) {
|
|
Record *Inst = Insts[i];
|
|
if (DagInit *PatternInit =
|
|
dynamic_cast<DagInit*>(Inst->getValueInit("Pattern"))) {
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void InstrSelectorEmitter::run(std::ostream &OS) {
|
|
// Type-check all of the node types to ensure we "understand" them.
|
|
ProcessNodeTypes();
|
|
|
|
// Read all of the instruction patterns in...
|
|
ProcessInstructionPatterns();
|
|
|
|
// Read all of the Expander patterns in...
|
|
|
|
}
|