else
return Error(L, "unrecognized syntax mode in .syntax directive");
- if (getLexer().isNot(AsmToken::EndOfStatement))
- return Error(Parser.getTok().getLoc(), "unexpected token in directive");
+ if (getLexer().isNot(AsmToken::EndOfStatement)) {
+ Error(Parser.getTok().getLoc(), "unexpected token in directive");
+ return false;
+ }
Parser.Lex();
// TODO tell the MC streamer the mode
/// ::= .code 16 | 32
bool ARMAsmParser::parseDirectiveCode(SMLoc L) {
const AsmToken &Tok = Parser.getTok();
- if (Tok.isNot(AsmToken::Integer))
- return Error(L, "unexpected token in .code directive");
+ if (Tok.isNot(AsmToken::Integer)) {
+ Error(L, "unexpected token in .code directive");
+ return false;
+ }
int64_t Val = Parser.getTok().getIntVal();
- if (Val == 16)
- Parser.Lex();
- else if (Val == 32)
- Parser.Lex();
- else
- return Error(L, "invalid operand to .code directive");
+ if (Val != 16 && Val != 32) {
+ Error(L, "invalid operand to .code directive");
+ return false;
+ }
+ Parser.Lex();
- if (getLexer().isNot(AsmToken::EndOfStatement))
- return Error(Parser.getTok().getLoc(), "unexpected token in directive");
+ if (getLexer().isNot(AsmToken::EndOfStatement)) {
+ Error(Parser.getTok().getLoc(), "unexpected token in directive");
+ return false;
+ }
Parser.Lex();
if (Val == 16) {
- if (!hasThumb())
- return Error(L, "target does not support Thumb mode");
+ if (!hasThumb()) {
+ Error(L, "target does not support Thumb mode");
+ return false;
+ }
if (!isThumb())
SwitchMode();
getParser().getStreamer().EmitAssemblerFlag(MCAF_Code16);
} else {
- if (!hasARM())
- return Error(L, "target does not support ARM mode");
+ if (!hasARM()) {
+ Error(L, "target does not support ARM mode");
+ return false;
+ }
if (isThumb())
SwitchMode();
SMLoc SRegLoc, ERegLoc;
if (ParseRegister(Reg, SRegLoc, ERegLoc)) {
Parser.eatToEndOfStatement();
- return Error(SRegLoc, "register name expected");
+ Error(SRegLoc, "register name expected");
+ return false;
}
// Shouldn't be anything else.
if (Parser.getTok().isNot(AsmToken::EndOfStatement)) {
Parser.eatToEndOfStatement();
- return Error(Parser.getTok().getLoc(),
- "unexpected input in .req directive.");
+ Error(Parser.getTok().getLoc(), "unexpected input in .req directive.");
+ return false;
}
Parser.Lex(); // Consume the EndOfStatement
- if (RegisterReqs.GetOrCreateValue(Name, Reg).getValue() != Reg)
- return Error(SRegLoc, "redefinition of '" + Name +
- "' does not match original.");
+ if (RegisterReqs.GetOrCreateValue(Name, Reg).getValue() != Reg) {
+ Error(SRegLoc, "redefinition of '" + Name + "' does not match original.");
+ return false;
+ }
return false;
}
bool ARMAsmParser::parseDirectiveUnreq(SMLoc L) {
if (Parser.getTok().isNot(AsmToken::Identifier)) {
Parser.eatToEndOfStatement();
- return Error(L, "unexpected input in .unreq directive.");
+ Error(L, "unexpected input in .unreq directive.");
+ return false;
}
RegisterReqs.erase(Parser.getTok().getIdentifier());
Parser.Lex(); // Eat the identifier.
#include "MCTargetDesc/ARMArchName.def"
.Default(ARM::INVALID_ARCH);
- if (ID == ARM::INVALID_ARCH)
- return Error(L, "Unknown arch name");
+ if (ID == ARM::INVALID_ARCH) {
+ Error(L, "Unknown arch name");
+ return false;
+ }
getTargetStreamer().emitArch(ID);
return false;
/// parseDirectiveEabiAttr
/// ::= .eabi_attribute int, int
bool ARMAsmParser::parseDirectiveEabiAttr(SMLoc L) {
- if (Parser.getTok().isNot(AsmToken::Integer))
- return Error(L, "integer expected");
+ if (Parser.getTok().isNot(AsmToken::Integer)) {
+ Error(L, "integer expected");
+ return false;
+ }
int64_t Tag = Parser.getTok().getIntVal();
Parser.Lex(); // eat tag integer
- if (Parser.getTok().isNot(AsmToken::Comma))
- return Error(L, "comma expected");
+ if (Parser.getTok().isNot(AsmToken::Comma)) {
+ Error(L, "comma expected");
+ return false;
+ }
Parser.Lex(); // skip comma
L = Parser.getTok().getLoc();
- if (Parser.getTok().isNot(AsmToken::Integer))
- return Error(L, "integer expected");
+ if (Parser.getTok().isNot(AsmToken::Integer)) {
+ Error(L, "integer expected");
+ return false;
+ }
int64_t Value = Parser.getTok().getIntVal();
Parser.Lex(); // eat value integer
#include "ARMFPUName.def"
.Default(ARM::INVALID_FPU);
- if (ID == ARM::INVALID_FPU)
- return Error(L, "Unknown FPU name");
+ if (ID == ARM::INVALID_FPU) {
+ Error(L, "Unknown FPU name");
+ return false;
+ }
getTargetStreamer().emitFPU(ID);
return false;
if (FnStartLoc.isValid()) {
Error(L, ".fnstart starts before the end of previous one");
Error(FnStartLoc, "previous .fnstart starts here");
- return true;
+ return false;
}
FnStartLoc = L;
/// ::= .fnend
bool ARMAsmParser::parseDirectiveFnEnd(SMLoc L) {
// Check the ordering of unwind directives
- if (!FnStartLoc.isValid())
- return Error(L, ".fnstart must precede .fnend directive");
+ if (!FnStartLoc.isValid()) {
+ Error(L, ".fnstart must precede .fnend directive");
+ return false;
+ }
// Reset the unwind directives parser state
resetUnwindDirectiveParserState();
bool ARMAsmParser::parseDirectiveCantUnwind(SMLoc L) {
// Check the ordering of unwind directives
CantUnwindLoc = L;
- if (!FnStartLoc.isValid())
- return Error(L, ".fnstart must precede .cantunwind directive");
+ if (!FnStartLoc.isValid()) {
+ Error(L, ".fnstart must precede .cantunwind directive");
+ return false;
+ }
if (HandlerDataLoc.isValid()) {
Error(L, ".cantunwind can't be used with .handlerdata directive");
Error(HandlerDataLoc, ".handlerdata was specified here");
- return true;
+ return false;
}
if (PersonalityLoc.isValid()) {
Error(L, ".cantunwind can't be used with .personality directive");
Error(PersonalityLoc, ".personality was specified here");
- return true;
+ return false;
}
getTargetStreamer().emitCantUnwind();
bool ARMAsmParser::parseDirectivePersonality(SMLoc L) {
// Check the ordering of unwind directives
PersonalityLoc = L;
- if (!FnStartLoc.isValid())
- return Error(L, ".fnstart must precede .personality directive");
+ if (!FnStartLoc.isValid()) {
+ Error(L, ".fnstart must precede .personality directive");
+ return false;
+ }
if (CantUnwindLoc.isValid()) {
Error(L, ".personality can't be used with .cantunwind directive");
Error(CantUnwindLoc, ".cantunwind was specified here");
- return true;
+ return false;
}
if (HandlerDataLoc.isValid()) {
Error(L, ".personality must precede .handlerdata directive");
Error(HandlerDataLoc, ".handlerdata was specified here");
- return true;
+ return false;
}
// Parse the name of the personality routine
if (Parser.getTok().isNot(AsmToken::Identifier)) {
Parser.eatToEndOfStatement();
- return Error(L, "unexpected input in .personality directive.");
+ Error(L, "unexpected input in .personality directive.");
+ return false;
}
StringRef Name(Parser.getTok().getIdentifier());
Parser.Lex();
bool ARMAsmParser::parseDirectiveHandlerData(SMLoc L) {
// Check the ordering of unwind directives
HandlerDataLoc = L;
- if (!FnStartLoc.isValid())
- return Error(L, ".fnstart must precede .personality directive");
+ if (!FnStartLoc.isValid()) {
+ Error(L, ".fnstart must precede .personality directive");
+ return false;
+ }
if (CantUnwindLoc.isValid()) {
Error(L, ".handlerdata can't be used with .cantunwind directive");
Error(CantUnwindLoc, ".cantunwind was specified here");
- return true;
+ return false;
}
getTargetStreamer().emitHandlerData();
/// ::= .setfp fpreg, spreg [, offset]
bool ARMAsmParser::parseDirectiveSetFP(SMLoc L) {
// Check the ordering of unwind directives
- if (!FnStartLoc.isValid())
- return Error(L, ".fnstart must precede .setfp directive");
- if (HandlerDataLoc.isValid())
- return Error(L, ".setfp must precede .handlerdata directive");
+ if (!FnStartLoc.isValid()) {
+ Error(L, ".fnstart must precede .setfp directive");
+ return false;
+ }
+ if (HandlerDataLoc.isValid()) {
+ Error(L, ".setfp must precede .handlerdata directive");
+ return false;
+ }
// Parse fpreg
SMLoc NewFPRegLoc = Parser.getTok().getLoc();
int NewFPReg = tryParseRegister();
- if (NewFPReg == -1)
- return Error(NewFPRegLoc, "frame pointer register expected");
+ if (NewFPReg == -1) {
+ Error(NewFPRegLoc, "frame pointer register expected");
+ return false;
+ }
// Consume comma
- if (!Parser.getTok().is(AsmToken::Comma))
- return Error(Parser.getTok().getLoc(), "comma expected");
+ if (!Parser.getTok().is(AsmToken::Comma)) {
+ Error(Parser.getTok().getLoc(), "comma expected");
+ return false;
+ }
Parser.Lex(); // skip comma
// Parse spreg
SMLoc NewSPRegLoc = Parser.getTok().getLoc();
int NewSPReg = tryParseRegister();
- if (NewSPReg == -1)
- return Error(NewSPRegLoc, "stack pointer register expected");
+ if (NewSPReg == -1) {
+ Error(NewSPRegLoc, "stack pointer register expected");
+ return false;
+ }
- if (NewSPReg != ARM::SP && NewSPReg != FPReg)
- return Error(NewSPRegLoc,
- "register should be either $sp or the latest fp register");
+ if (NewSPReg != ARM::SP && NewSPReg != FPReg) {
+ Error(NewSPRegLoc,
+ "register should be either $sp or the latest fp register");
+ return false;
+ }
// Update the frame pointer register
FPReg = NewFPReg;
if (Parser.getTok().isNot(AsmToken::Hash) &&
Parser.getTok().isNot(AsmToken::Dollar)) {
- return Error(Parser.getTok().getLoc(), "'#' expected");
+ Error(Parser.getTok().getLoc(), "'#' expected");
+ return false;
}
Parser.Lex(); // skip hash token.
const MCExpr *OffsetExpr;
SMLoc ExLoc = Parser.getTok().getLoc();
SMLoc EndLoc;
- if (getParser().parseExpression(OffsetExpr, EndLoc))
- return Error(ExLoc, "malformed setfp offset");
+ if (getParser().parseExpression(OffsetExpr, EndLoc)) {
+ Error(ExLoc, "malformed setfp offset");
+ return false;
+ }
const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(OffsetExpr);
- if (!CE)
- return Error(ExLoc, "setfp offset must be an immediate");
+ if (!CE) {
+ Error(ExLoc, "setfp offset must be an immediate");
+ return false;
+ }
Offset = CE->getValue();
}
/// ::= .pad offset
bool ARMAsmParser::parseDirectivePad(SMLoc L) {
// Check the ordering of unwind directives
- if (!FnStartLoc.isValid())
- return Error(L, ".fnstart must precede .pad directive");
- if (HandlerDataLoc.isValid())
- return Error(L, ".pad must precede .handlerdata directive");
+ if (!FnStartLoc.isValid()) {
+ Error(L, ".fnstart must precede .pad directive");
+ return false;
+ }
+ if (HandlerDataLoc.isValid()) {
+ Error(L, ".pad must precede .handlerdata directive");
+ return false;
+ }
// Parse the offset
if (Parser.getTok().isNot(AsmToken::Hash) &&
Parser.getTok().isNot(AsmToken::Dollar)) {
- return Error(Parser.getTok().getLoc(), "'#' expected");
+ Error(Parser.getTok().getLoc(), "'#' expected");
+ return false;
}
Parser.Lex(); // skip hash token.
const MCExpr *OffsetExpr;
SMLoc ExLoc = Parser.getTok().getLoc();
SMLoc EndLoc;
- if (getParser().parseExpression(OffsetExpr, EndLoc))
- return Error(ExLoc, "malformed pad offset");
+ if (getParser().parseExpression(OffsetExpr, EndLoc)) {
+ Error(ExLoc, "malformed pad offset");
+ return false;
+ }
const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(OffsetExpr);
- if (!CE)
- return Error(ExLoc, "pad offset must be an immediate");
+ if (!CE) {
+ Error(ExLoc, "pad offset must be an immediate");
+ return false;
+ }
getTargetStreamer().emitPad(CE->getValue());
return false;
/// ::= .vsave { registers }
bool ARMAsmParser::parseDirectiveRegSave(SMLoc L, bool IsVector) {
// Check the ordering of unwind directives
- if (!FnStartLoc.isValid())
- return Error(L, ".fnstart must precede .save or .vsave directives");
- if (HandlerDataLoc.isValid())
- return Error(L, ".save or .vsave must precede .handlerdata directive");
+ if (!FnStartLoc.isValid()) {
+ Error(L, ".fnstart must precede .save or .vsave directives");
+ return false;
+ }
+ if (HandlerDataLoc.isValid()) {
+ Error(L, ".save or .vsave must precede .handlerdata directive");
+ return false;
+ }
// RAII object to make sure parsed operands are deleted.
struct CleanupObject {
if (parseRegisterList(CO.Operands))
return true;
ARMOperand *Op = (ARMOperand*)CO.Operands[0];
- if (!IsVector && !Op->isRegList())
- return Error(L, ".save expects GPR registers");
- if (IsVector && !Op->isDPRRegList())
- return Error(L, ".vsave expects DPR registers");
+ if (!IsVector && !Op->isRegList()) {
+ Error(L, ".save expects GPR registers");
+ return false;
+ }
+ if (IsVector && !Op->isDPRRegList()) {
+ Error(L, ".vsave expects DPR registers");
+ return false;
+ }
getTargetStreamer().emitRegSave(Op->getRegList(), IsVector);
return false;
break;
default:
Parser.eatToEndOfStatement();
- return Error(Loc, "cannot determine Thumb instruction size, "
- "use inst.n/inst.w instead");
+ Error(Loc, "cannot determine Thumb instruction size, "
+ "use inst.n/inst.w instead");
+ return false;
}
} else {
if (Suffix) {
Parser.eatToEndOfStatement();
- return Error(Loc, "width suffixes are invalid in ARM mode");
+ Error(Loc, "width suffixes are invalid in ARM mode");
+ return false;
}
Width = 4;
}
if (getLexer().is(AsmToken::EndOfStatement)) {
Parser.eatToEndOfStatement();
- return Error(Loc, "expected expression following directive");
+ Error(Loc, "expected expression following directive");
+ return false;
}
for (;;) {
const MCExpr *Expr;
- if (getParser().parseExpression(Expr))
- return Error(Loc, "expected expression");
+ if (getParser().parseExpression(Expr)) {
+ Error(Loc, "expected expression");
+ return false;
+ }
const MCConstantExpr *Value = dyn_cast_or_null<MCConstantExpr>(Expr);
- if (!Value)
- return Error(Loc, "expected constant expression");
+ if (!Value) {
+ Error(Loc, "expected constant expression");
+ return false;
+ }
switch (Width) {
case 2:
- if (Value->getValue() > 0xffff)
- return Error(Loc, "inst.n operand is too big, use inst.w instead");
+ if (Value->getValue() > 0xffff) {
+ Error(Loc, "inst.n operand is too big, use inst.w instead");
+ return false;
+ }
break;
case 4:
- if (Value->getValue() > 0xffffffff)
- return Error(Loc,
- StringRef(Suffix ? "inst.w" : "inst") + " operand is too big");
+ if (Value->getValue() > 0xffffffff) {
+ Error(Loc,
+ StringRef(Suffix ? "inst.w" : "inst") + " operand is too big");
+ return false;
+ }
break;
default:
llvm_unreachable("only supported widths are 2 and 4");
if (getLexer().is(AsmToken::EndOfStatement))
break;
- if (getLexer().isNot(AsmToken::Comma))
- return Error(Loc, "unexpected token in directive");
+ if (getLexer().isNot(AsmToken::Comma)) {
+ Error(Loc, "unexpected token in directive");
+ return false;
+ }
Parser.Lex();
}