void ARMMCInstLower::Lower(const MachineInstr *MI, MCInst &OutMI) const {
OutMI.setOpcode(MI->getOpcode());
for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
const MachineOperand &MO = MI->getOperand(i);
MCOperand MCOp;
switch (MO.getType()) {
default:
MI->dump();
assert(0 && "unknown operand type");
case MachineOperand::MO_Register:
// Ignore all non-CPSR implicit register operands.
if (MO.isImplicit() && MO.getReg() != ARM::CPSR) continue;
assert(!MO.getSubReg() && "Subregs should be eliminated!");
MCOp = MCOperand::CreateReg(MO.getReg());
break;
case MachineOperand::MO_Immediate:
MCOp = MCOperand::CreateImm(MO.getImm());
break;
case MachineOperand::MO_MachineBasicBlock:
MCOp = MCOperand::CreateExpr(MCSymbolRefExpr::Create(
MO.getMBB()->getSymbol(), Ctx));
break;
case MachineOperand::MO_GlobalAddress:
MCOp = LowerSymbolRefOperand(MO, GetSymbolRef(MO));
break;
case MachineOperand::MO_ExternalSymbol:
MCOp = LowerSymbolRefOperand(MO, GetExternalSymbolSymbol(MO));
break;
case MachineOperand::MO_JumpTableIndex:
MCOp = LowerSymbolOperand(MO, GetJumpTableSymbol(MO));
break;
case MachineOperand::MO_ConstantPoolIndex:
MCOp = LowerSymbolOperand(MO, GetConstantPoolIndexSymbol(MO));
break;
case MachineOperand::MO_BlockAddress:
MCOp = LowerSymbolOperand(MO, Printer.GetBlockAddressSymbol(
MO.getBlockAddress()));
break;
case MachineOperand::MO_FPImmediate:
APFloat Val = MO.getFPImm()->getValueAPF();
bool ignored;
Val.convert(APFloat::IEEEdouble, APFloat::rmTowardZero, &ignored);
MCOp = MCOperand::CreateFPImm(Val.convertToDouble());
break;
}
OutMI.addOperand(MCOp);
}
}
bool ARMAsmPrinter::lowerOperand(const MachineOperand &MO,
MCOperand &MCOp) {
switch (MO.getType()) {
default: llvm_unreachable("unknown operand type");
case MachineOperand::MO_Register:
// Ignore all non-CPSR implicit register operands.
if (MO.isImplicit() && MO.getReg() != ARM::CPSR)
return false;
assert(!MO.getSubReg() && "Subregs should be eliminated!");
MCOp = MCOperand::createReg(MO.getReg());
break;
case MachineOperand::MO_Immediate:
MCOp = MCOperand::createImm(MO.getImm());
break;
case MachineOperand::MO_MachineBasicBlock:
MCOp = MCOperand::createExpr(MCSymbolRefExpr::create(
MO.getMBB()->getSymbol(), OutContext));
break;
case MachineOperand::MO_GlobalAddress:
MCOp = GetSymbolRef(MO,
GetARMGVSymbol(MO.getGlobal(), MO.getTargetFlags()));
break;
case MachineOperand::MO_ExternalSymbol:
MCOp = GetSymbolRef(MO,
GetExternalSymbolSymbol(MO.getSymbolName()));
break;
case MachineOperand::MO_JumpTableIndex:
MCOp = GetSymbolRef(MO, GetJTISymbol(MO.getIndex()));
break;
case MachineOperand::MO_ConstantPoolIndex:
if (Subtarget->genExecuteOnly())
llvm_unreachable("execute-only should not generate constant pools");
MCOp = GetSymbolRef(MO, GetCPISymbol(MO.getIndex()));
break;
case MachineOperand::MO_BlockAddress:
MCOp = GetSymbolRef(MO, GetBlockAddressSymbol(MO.getBlockAddress()));
break;
case MachineOperand::MO_FPImmediate: {
APFloat Val = MO.getFPImm()->getValueAPF();
bool ignored;
Val.convert(APFloat::IEEEdouble(), APFloat::rmTowardZero, &ignored);
MCOp = MCOperand::createFPImm(Val.convertToDouble());
break;
}
case MachineOperand::MO_RegisterMask:
// Ignore call clobbers.
return false;
}
return true;
}
bool EpiphanyAsmPrinter::lowerOperand(const MachineOperand &MO,
MCOperand &MCOp) const {
switch (MO.getType()) {
default:
llvm_unreachable("unknown operand type");
case MachineOperand::MO_Register:
if (MO.isImplicit())
return false;
assert(!MO.getSubReg() && "Subregs should be eliminated!");
MCOp = MCOperand::CreateReg(MO.getReg());
break;
case MachineOperand::MO_Immediate:
MCOp = MCOperand::CreateImm(MO.getImm());
break;
case MachineOperand::MO_FPImmediate: {// a bit hacky, see arm
APFloat Val = MO.getFPImm()->getValueAPF();
bool ignored;
Val.convert(APFloat::IEEEdouble, APFloat::rmTowardZero, &ignored);
MCOp = MCOperand::CreateFPImm(Val.convertToDouble());
break;
}
case MachineOperand::MO_BlockAddress:
MCOp = lowerSymbolOperand(MO, GetBlockAddressSymbol(MO.getBlockAddress()));
break;
case MachineOperand::MO_ExternalSymbol:
MCOp = lowerSymbolOperand(MO, GetExternalSymbolSymbol(MO.getSymbolName()));
break;
case MachineOperand::MO_GlobalAddress:
MCOp = lowerSymbolOperand(MO, Mang->getSymbol(MO.getGlobal()));
break;
case MachineOperand::MO_MachineBasicBlock:
MCOp = MCOperand::CreateExpr(MCSymbolRefExpr::Create(
MO.getMBB()->getSymbol(), OutContext));
break;
case MachineOperand::MO_JumpTableIndex:
MCOp = lowerSymbolOperand(MO, GetJTISymbol(MO.getIndex()));
break;
case MachineOperand::MO_ConstantPoolIndex:
MCOp = lowerSymbolOperand(MO, GetCPISymbol(MO.getIndex()));
break;
case MachineOperand::MO_RegisterMask:
// Ignore call clobbers
return false;
}
return true;
}
bool ARMAsmPrinter::lowerOperand(const MachineOperand &MO,
MCOperand &MCOp) {
switch (MO.getType()) {
default:
assert(0 && "unknown operand type");
return false;
case MachineOperand::MO_Register:
// Ignore all non-CPSR implicit register operands.
if (MO.isImplicit() && MO.getReg() != ARM::CPSR)
return false;
assert(!MO.getSubReg() && "Subregs should be eliminated!");
MCOp = MCOperand::CreateReg(MO.getReg());
break;
case MachineOperand::MO_Immediate:
MCOp = MCOperand::CreateImm(MO.getImm());
break;
case MachineOperand::MO_MachineBasicBlock:
MCOp = MCOperand::CreateExpr(MCSymbolRefExpr::Create(
MO.getMBB()->getSymbol(), OutContext));
break;
case MachineOperand::MO_GlobalAddress:
MCOp = GetSymbolRef(MO, Mang->getSymbol(MO.getGlobal()));
break;
case MachineOperand::MO_ExternalSymbol:
MCOp = GetSymbolRef(MO,
GetExternalSymbolSymbol(MO.getSymbolName()));
break;
case MachineOperand::MO_JumpTableIndex:
MCOp = GetSymbolRef(MO, GetJTISymbol(MO.getIndex()));
break;
case MachineOperand::MO_ConstantPoolIndex:
MCOp = GetSymbolRef(MO, GetCPISymbol(MO.getIndex()));
break;
case MachineOperand::MO_BlockAddress:
MCOp = GetSymbolRef(MO, GetBlockAddressSymbol(MO.getBlockAddress()));
break;
case MachineOperand::MO_FPImmediate: {
APFloat Val = MO.getFPImm()->getValueAPF();
bool ignored;
Val.convert(APFloat::IEEEdouble, APFloat::rmTowardZero, &ignored);
MCOp = MCOperand::CreateFPImm(Val.convertToDouble());
break;
}
}
return true;
}
MCOperand PTXAsmPrinter::lowerOperand(const MachineOperand &MO) {
MCOperand MCOp;
const PTXMachineFunctionInfo *MFI = MF->getInfo<PTXMachineFunctionInfo>();
const MCExpr *Expr;
const char *RegSymbolName;
switch (MO.getType()) {
default:
llvm_unreachable("Unknown operand type");
case MachineOperand::MO_Register:
// We create register operands as symbols, since the PTXInstPrinter class
// has no way to map virtual registers back to a name without some ugly
// hacks.
// FIXME: Figure out a better way to handle virtual register naming.
RegSymbolName = MFI->getRegisterName(MO.getReg());
Expr = MCSymbolRefExpr::Create(RegSymbolName, MCSymbolRefExpr::VK_None,
OutContext);
MCOp = MCOperand::CreateExpr(Expr);
break;
case MachineOperand::MO_Immediate:
MCOp = MCOperand::CreateImm(MO.getImm());
break;
case MachineOperand::MO_MachineBasicBlock:
MCOp = MCOperand::CreateExpr(MCSymbolRefExpr::Create(
MO.getMBB()->getSymbol(), OutContext));
break;
case MachineOperand::MO_GlobalAddress:
MCOp = GetSymbolRef(MO, Mang->getSymbol(MO.getGlobal()));
break;
case MachineOperand::MO_ExternalSymbol:
MCOp = GetSymbolRef(MO, GetExternalSymbolSymbol(MO.getSymbolName()));
break;
case MachineOperand::MO_FPImmediate:
APFloat Val = MO.getFPImm()->getValueAPF();
bool ignored;
Val.convert(APFloat::IEEEdouble, APFloat::rmTowardZero, &ignored);
MCOp = MCOperand::CreateFPImm(Val.convertToDouble());
break;
}
return MCOp;
}
int SSPParser::getNextToken(void *Val) {
YYSTYPE *Value = static_cast<YYSTYPE*>(Val);
StringRef BufferData = Buf->getBuffer();
const char *Data = BufferData.data();
const char* CurCh = Data+CurPos;
while (CurPos < BufferData.size() &&
(*CurCh == '\t' || *CurCh == ' ' || *CurCh == '\r' ||
*CurCh == '\n')) {
CurPos++;
CurCh = Data+CurPos;
}
if (CurPos >= BufferData.size())
return 0; // EOF
if (*CurCh == '+') {
CurPos++;
return PLUS;
} else if (*CurCh == '-') {
CurPos++;
return MINUS;
} else if (*CurCh == '*') {
CurPos++;
return ASTERISK;
} else if (*CurCh == '/') {
CurPos++;
return SLASH;
} else if (*CurCh == '$') {
CurPos++;
return DOLLAR;
} else if (*CurCh == '@') {
CurPos++;
return AT;
} else if (IsAlpha(*CurCh)) {
const char *Start = CurCh;
size_t Length = 0;
do {
Length++;
CurPos++;
CurCh = Data+CurPos;
} while (CurPos < BufferData.size() && (IsAlphaOrDigit(*CurCh) || *CurCh == '_'));
StringRef *Str = new StringRef(Start, Length);
// Check for keywords
if (Str->compare("double") == 0) {
return DOUBLE;
} else if (Str->compare("field") == 0) {
return FIELD;
} else if (Str->compare("float") == 0) {
return FLOAT;
} else if (Str->compare("grid") == 0) {
return GRID;
} else if (Str->compare("in") == 0) {
return IN;
} else if (Str->compare("inout") == 0) {
return INOUT;
} else if (Str->compare("is") == 0) {
return IS;
} else if (Str->compare("let") == 0) {
return LET;
} else if (Str->compare("out") == 0) {
return OUT;
} else if (Str->compare("param") == 0) {
return PARAM;
} else if (Str->compare("program") == 0) {
return PROGRAM;
}
// Not a keyword
InternedStrings.push_back(Str);
Value->Ident = Str;
return IDENT;
} else if (IsDigit(*CurCh)) {
const char *Start = CurCh;
size_t Length = 0;
bool IsFloat = false;
do {
if (*CurCh == '.') IsFloat = true;
Length++;
CurPos++;
CurCh = Data+CurPos;
} while (CurPos < BufferData.size() && (IsDigit(*CurCh) || *CurCh == '.'));
if (CurPos < BufferData.size() && (*CurCh == 'e' || *CurCh == 'E')) {
// Start of an exponent
IsFloat = true;
CurPos++;
CurCh = Data+CurPos;
Length++;
if (CurPos == BufferData.size() || (!IsDigit(*CurCh) && *CurCh != '-')) {
SrcMgr.PrintMessage(SMLoc::getFromPointer(Data+CurPos),
SourceMgr::DK_Error, "Missing exponent");
return 0;
}
if (*CurCh == '-') {
Length++;
CurPos++;
CurCh = Data+CurPos;
if (CurPos == BufferData.size() || !IsDigit(*CurCh)) {
SrcMgr.PrintMessage(SMLoc::getFromPointer(Data+CurPos),
SourceMgr::DK_Error, "Missing exponent");
return 0;
}
}
do {
Length++;
CurPos++;
CurCh = Data+CurPos;
} while (CurPos < BufferData.size() && IsDigit(*CurCh));
}
StringRef Str = StringRef(Start, Length);
if (IsFloat) {
APFloat DoubleValue = APFloat(APFloat::IEEEdouble, Str);
Value->DoubleConst = DoubleValue.convertToDouble();
return DOUBLECONST;
} else {
long IntValue = atol(Str.data());
Value->IntConst = IntValue;
return INTCONST;
}
} else if (*CurCh == '=') {
CurPos++;
return EQUALS;
} else if (*CurCh == '(') {
CurPos++;
return OPENPARENS;
} else if (*CurCh == ')') {
CurPos++;
return CLOSEPARENS;
} else if (*CurCh == '[') {
CurPos++;
return OPENBRACE;
} else if (*CurCh == ']') {
CurPos++;
return CLOSEBRACE;
} else if (*CurCh == ',') {
CurPos++;
return COMMA;
} else if (*CurCh == ':') {
CurPos++;
return COLON;
}
CurPos++;
// If we get here, then we have no idea how to lex this!
printError("Unknown symbol");
return 0;
}