[AArch64][AsmParser] NFC: Parser.getTok().getLoc() -> getLoc()

[tmatheson]

llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

3165

Does parseExpression above update the current token and hence the location?

[c-rhodes]

address @tmatheson comment

[c-rhodes]

llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

3165

Does parseExpression above update the current token and hence the location?

Yeah thanks for pointing that out I missed that. There's actually a test for this already in llvm/test/MC/AArch64/shift_extend_op_w_symbol.s but whitespace was being ignored so the ^ could have been anywhere and it would pass. I've updated it to use --match-full-lines --strict-whitespace.

llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

AArch64AsmParser::tryParseImmWithOptionalShift(OperandVector &Operands) {
   else if (Parser.getTok().isNot(AsmToken::Integer))
     // Operand should start from # or should be integer, emit error otherwise.
     return MatchOperand_NoMatch;
 
   const MCExpr *Imm = nullptr;
   if (parseSymbolicImmVal(Imm))
     return MatchOperand_ParseFail;
   else if (Parser.getTok().isNot(AsmToken::Comma)) {
-    SMLoc E = Parser.getTok().getLoc();
     Operands.push_back(
-        AArch64Operand::CreateImm(Imm, S, E, getContext()));
+        AArch64Operand::CreateImm(Imm, S, getLoc(), getContext()));
     return MatchOperand_Success;
   }
 
   // Eat ','
   Parser.Lex();
 
   // The optional operand must be "lsl #N" where N is non-negative.
   if (!Parser.getTok().is(AsmToken::Identifier) ||
       !Parser.getTok().getIdentifier().equals_insensitive("lsl")) {
-    Error(Parser.getTok().getLoc(), "only 'lsl #+N' valid after immediate");
+    Error(getLoc(), "only 'lsl #+N' valid after immediate");
     return MatchOperand_ParseFail;
   }
 
   // Eat 'lsl'
   Parser.Lex();
 
   parseOptionalToken(AsmToken::Hash);
 
   if (Parser.getTok().isNot(AsmToken::Integer)) {
-    Error(Parser.getTok().getLoc(), "only 'lsl #+N' valid after immediate");
+    Error(getLoc(), "only 'lsl #+N' valid after immediate");
     return MatchOperand_ParseFail;
   }
 
   int64_t ShiftAmount = Parser.getTok().getIntVal();
 
   if (ShiftAmount < 0) {
-    Error(Parser.getTok().getLoc(), "positive shift amount required");
+    Error(getLoc(), "positive shift amount required");
     return MatchOperand_ParseFail;
   }
   Parser.Lex(); // Eat the number
 
   // Just in case the optional lsl #0 is used for immediates other than zero.
   if (ShiftAmount == 0 && Imm != nullptr) {
-    SMLoc E = Parser.getTok().getLoc();
-    Operands.push_back(AArch64Operand::CreateImm(Imm, S, E, getContext()));
+    Operands.push_back(
+        AArch64Operand::CreateImm(Imm, S, getLoc(), getContext()));
     return MatchOperand_Success;
   }
 
-  SMLoc E = Parser.getTok().getLoc();
-  Operands.push_back(AArch64Operand::CreateShiftedImm(Imm, ShiftAmount,
-                                                      S, E, getContext()));
+  Operands.push_back(AArch64Operand::CreateShiftedImm(Imm, ShiftAmount, S,
+                                                      getLoc(), getContext()));
   return MatchOperand_Success;
 }
 
 /// parseCondCodeString - Parse a Condition Code string.
 AArch64CC::CondCode AArch64AsmParser::parseCondCodeString(StringRef Cond) {
   AArch64CC::CondCode CC = StringSwitch<AArch64CC::CondCode>(Cond.lower())
                     .Case("eq", AArch64CC::EQ)
                     .Case("ne", AArch64CC::NE)
if (!Hash && getLexer().isNot(AsmToken::Integer)) {
     SMLoc E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
     Operands.push_back(
         AArch64Operand::CreateShiftExtend(ShOp, 0, false, S, E, getContext()));
     return MatchOperand_Success;
   }
 
   // Make sure we do actually have a number, identifier or a parenthesized
   // expression.
-  SMLoc E = Parser.getTok().getLoc();
+  SMLoc E = getLoc();
   if (!Parser.getTok().is(AsmToken::Integer) &&
       !Parser.getTok().is(AsmToken::LParen) &&
       !Parser.getTok().is(AsmToken::Identifier)) {
     Error(E, "expected integer shift amount");
     return MatchOperand_ParseFail;
   }
 
   const MCExpr *ImmVal;
   if (getParser().parseExpression(ImmVal))
     return MatchOperand_ParseFail;
 
   const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(ImmVal);
   if (!MCE) {
     Error(E, "expected constant '#imm' after shift specifier");
     return MatchOperand_ParseFail;
   }
 
   E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
   Operands.push_back(AArch64Operand::CreateShiftExtend(
       ShOp, MCE->getValue(), true, S, E, getContext()));
   return MatchOperand_Success;
 }
default: {
     if (parseSymbolicImmVal(Expr))
       return Error(S, "invalid operand");
 
     SMLoc E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
     Operands.push_back(AArch64Operand::CreateImm(Expr, S, E, getContext()));
     return false;
   }
   case AsmToken::LBrac: {
-    SMLoc Loc = Parser.getTok().getLoc();
-    Operands.push_back(AArch64Operand::CreateToken("[", Loc, getContext()));
+    Operands.push_back(
+        AArch64Operand::CreateToken("[", getLoc(), getContext()));
     Parser.Lex(); // Eat '['
 
     // There's no comma after a '[', so we can parse the next operand
     // immediately.
     return parseOperand(Operands, false, false);
   }
   case AsmToken::LCurly: {
     if (!parseNeonVectorList(Operands))
       return false;
 
-    SMLoc Loc = Parser.getTok().getLoc();
-    Operands.push_back(AArch64Operand::CreateToken("{", Loc, getContext()));
+    Operands.push_back(
+        AArch64Operand::CreateToken("{", getLoc(), getContext()));
     Parser.Lex(); // Eat '{'
 
     // There's no comma after a '{', so we can parse the next operand
     // immediately.
     return parseOperand(Operands, false, false);
   }
   case AsmToken::Identifier: {
     // If we're expecting a Condition Code operand, then just parse that.

llvm/test/MC/AArch64/shift_extend_op_w_symbol.s

 // RUN: not llvm-mc -triple aarch64-none-linux-gnu < %s > %t1 2> %t2
 // RUN: FileCheck < %t1 %s
-// RUN: FileCheck --check-prefix=CHECK-ERROR < %t2 %s
+// RUN: FileCheck --match-full-lines --strict-whitespace --check-prefix=CHECK-ERROR < %t2 %s
 
         .globl _func
 _func:
 // CHECK-LABEL: _func
 
         .set IMM2, 2
         .equ IMM4, 4
 

 // CHECK: add w1, w2, w3, sxtb #2
 // CHECK: add w4, w5, w6, sxth #4
 // CHECK: add x7, x8, x9, lsl #2
 // CHECK: add w7, w8, w9, sxtw #2
 // CHECK: add x1, x2, x3, sxtx #4
 
         add w1, w2, w3, lsl #IMM3
 
-// CHECK-ERROR: error: expected constant '#imm' after shift specifier
+// CHECK-ERROR:{{.*}}error: expected constant '#imm' after shift specifier
 // CHECK-ERROR:        add w1, w2, w3, lsl #IMM3
 // CHECK-ERROR:                             ^