maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Revert "[ms] [llvm-ml] Add support for .radix directive, and accept all radix specifiers" 

This reverts commit 5dd1b6d612.
This commit is contained in:
Eric Astor 2020-09-23 13:57:43 -04:00
parent 7a3c643c35
commit b901b6ab17
7 changed files with 22 additions and 288 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
llvm/include/llvm/MC/MCParser/MCAsmLexer.h
View File

@ -50,7 +50,6 @@ protected: // Can only create subclasses.
bool AllowAtInIdentifier;
bool IsAtStartOfStatement = true;
bool LexMasmIntegers = false;
unsigned DefaultRadix = 10;
AsmCommentConsumer *CommentConsumer = nullptr;
MCAsmLexer();
@ -144,9 +143,6 @@ public:
bool getAllowAtInIdentifier() { return AllowAtInIdentifier; }
void setAllowAtInIdentifier(bool v) { AllowAtInIdentifier = v; }
unsigned getDefaultRadix() const { return DefaultRadix; }
void setDefaultRadix(unsigned Radix) { DefaultRadix = Radix; }
void setCommentConsumer(AsmCommentConsumer *CommentConsumer) {
this->CommentConsumer = CommentConsumer;
}

122
llvm/lib/MC/MCParser/AsmLexer.cpp
View File

@ -18,7 +18,6 @@
#include "llvm/ADT/StringSwitch.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCParser/MCAsmLexer.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/SMLoc.h"
#include "llvm/Support/SaveAndRestore.h"
#include <cassert>
@ -272,13 +271,6 @@ static unsigned doHexLookAhead(const char *&CurPtr, unsigned DefaultRadix,
return DefaultRadix;
}
static const char *findLastDigit(const char *CurPtr, unsigned DefaultRadix) {
while (hexDigitValue(*CurPtr) < DefaultRadix) {
++CurPtr;
}
return CurPtr;
}
static AsmToken intToken(StringRef Ref, APInt &Value)
{
if (Value.isIntN(64))
@ -286,21 +278,6 @@ static AsmToken intToken(StringRef Ref, APInt &Value)
return AsmToken(AsmToken::BigNum, Ref, Value);
}
static std::string radixName(unsigned Radix) {
switch (Radix) {
case 2:
return "binary";
case 8:
return "octal";
case 10:
return "decimal";
case 16:
return "hexadecimal";
default:
return "base-" + std::to_string(Radix);
}
}
/// LexDigit: First character is [0-9].
/// Local Label: [0-9][:]
/// Forward/Backward Label: [0-9][fb]
@ -309,108 +286,45 @@ static std::string radixName(unsigned Radix) {
/// Hex integer: 0x[0-9a-fA-F]+ or [0x]?[0-9][0-9a-fA-F]*[hH]
/// Decimal integer: [1-9][0-9]*
AsmToken AsmLexer::LexDigit() {
// MASM-flavor binary integer: [01]+[yY] (if DefaultRadix < 16, [bByY])
// MASM-flavor octal integer: [0-7]+[oOqQ]
// MASM-flavor decimal integer: [0-9]+[tT] (if DefaultRadix < 16, [dDtT])
// MASM-flavor binary integer: [01]+[bB]
// MASM-flavor hexadecimal integer: [0-9][0-9a-fA-F]*[hH]
if (LexMasmIntegers && isdigit(CurPtr[-1])) {
const char *FirstNonBinary =
(CurPtr[-1] != '0' && CurPtr[-1] != '1') ? CurPtr - 1 : nullptr;
const char *FirstNonDecimal =
(CurPtr[-1] < '0' || CurPtr[-1] > '9') ? CurPtr - 1 : nullptr;
const char *FirstNonBinary = (CurPtr[-1] != '0' && CurPtr[-1] != '1') ?
CurPtr - 1 : nullptr;
const char *OldCurPtr = CurPtr;
while (isHexDigit(*CurPtr)) {
switch (*CurPtr) {
default:
if (!FirstNonDecimal) {
FirstNonDecimal = CurPtr;
}
LLVM_FALLTHROUGH;
case '9':
case '8':
case '7':
case '6':
case '5':
case '4':
case '3':
case '2':
if (!FirstNonBinary) {
FirstNonBinary = CurPtr;
}
break;
case '1':
case '0':
break;
}
if (*CurPtr != '0' && *CurPtr != '1' && !FirstNonBinary)
FirstNonBinary = CurPtr;
++CurPtr;
}
if (*CurPtr == '.') {
// MASM float literals (other than hex floats) always contain a ".", and
// are always written in decimal.
++CurPtr;
return LexFloatLiteral();
}
unsigned Radix = 0;
if (*CurPtr == 'h' || *CurPtr == 'H') {
// hexadecimal number
++CurPtr;
Radix = 16;
} else if (*CurPtr == 't' || *CurPtr == 'T') {
// decimal number
++CurPtr;
Radix = 10;
} else if (*CurPtr == 'o' || *CurPtr == 'O' || *CurPtr == 'q' ||
*CurPtr == 'Q') {
// octal number
++CurPtr;
Radix = 8;
} else if (*CurPtr == 'y' || *CurPtr == 'Y') {
// binary number
++CurPtr;
Radix = 2;
} else if (FirstNonDecimal && FirstNonDecimal + 1 == CurPtr &&
DefaultRadix < 14 &&
(*FirstNonDecimal == 'd' || *FirstNonDecimal == 'D')) {
Radix = 10;
} else if (FirstNonBinary && FirstNonBinary + 1 == CurPtr &&
DefaultRadix < 12 &&
(*FirstNonBinary == 'b' || *FirstNonBinary == 'B')) {
(*FirstNonBinary == 'b' || *FirstNonBinary == 'B'))
Radix = 2;
}
if (Radix) {
if (Radix == 2 || Radix == 16) {
StringRef Result(TokStart, CurPtr - TokStart);
APInt Value(128, 0, true);
if (Result.drop_back().getAsInteger(Radix, Value))
return ReturnError(TokStart, "invalid " + radixName(Radix) + " number");
return ReturnError(TokStart, Radix == 2 ? "invalid binary number" :
"invalid hexdecimal number");
// MSVC accepts and ignores type suffices on integer literals.
SkipIgnoredIntegerSuffix(CurPtr);
return intToken(Result, Value);
}
}
// default-radix integers, or floating point numbers, fall through
// octal/decimal integers, or floating point numbers, fall through
CurPtr = OldCurPtr;
}
// MASM default-radix integers: [0-9a-fA-F]+
// (All other integer literals have a radix specifier.)
if (LexMasmIntegers) {
CurPtr = findLastDigit(CurPtr, 16);
StringRef Result(TokStart, CurPtr - TokStart);
APInt Value(128, 0, true);
if (Result.getAsInteger(DefaultRadix, Value)) {
return ReturnError(TokStart,
"invalid " + radixName(DefaultRadix) + " number");
}
return intToken(Result, Value);
}
// Decimal integer: [1-9][0-9]*
if (CurPtr[-1] != '0' || CurPtr[0] == '.') {
unsigned Radix = doHexLookAhead(CurPtr, 10, LexMasmIntegers);
@ -425,9 +339,13 @@ AsmToken AsmLexer::LexDigit() {
StringRef Result(TokStart, CurPtr - TokStart);
APInt Value(128, 0, true);
if (Result.getAsInteger(Radix, Value)) {
return ReturnError(TokStart, "invalid " + radixName(Radix) + " number");
}
if (Result.getAsInteger(Radix, Value))
return ReturnError(TokStart, !isHex ? "invalid decimal number" :
"invalid hexdecimal number");
// Consume the [hH].
if (LexMasmIntegers && Radix == 16)
++CurPtr;
// The darwin/x86 (and x86-64) assembler accepts and ignores type
// suffices on integer literals.
@ -498,9 +416,11 @@ AsmToken AsmLexer::LexDigit() {
// Either octal or hexadecimal.
APInt Value(128, 0, true);
unsigned Radix = doHexLookAhead(CurPtr, 8, LexMasmIntegers);
bool isHex = Radix == 16;
StringRef Result(TokStart, CurPtr - TokStart);
if (Result.getAsInteger(Radix, Value))
return ReturnError(TokStart, "invalid " + radixName(Radix) + " number");
return ReturnError(TokStart, !isHex ? "invalid octal number" :
"invalid hexdecimal number");
// Consume the [hH].
if (Radix == 16)

1
llvm/lib/MC/MCParser/COFFMasmParser.cpp
View File

@ -132,6 +132,7 @@ class COFFMasmParser : public MCAsmParserExtension {
// option
// popcontext
// pushcontext
// .radix
// .safeseh
// Procedure directives

23
llvm/lib/MC/MCParser/MasmParser.cpp
View File

@ -732,7 +732,6 @@ private:
DK_SAVEREG,
DK_SAVEXMM128,
DK_SETFRAME,
DK_RADIX,
};
/// Maps directive name --> DirectiveKind enum, for directives parsed by this
@ -965,9 +964,6 @@ private:
// ".erre" or ".errnz", depending on ExpectZero.
bool parseDirectiveErrorIfe(SMLoc DirectiveLoc, bool ExpectZero);
// ".radix"
bool parseDirectiveRadix(SMLoc DirectiveLoc);
// "echo"
bool parseDirectiveEcho();
@ -2288,8 +2284,6 @@ bool MasmParser::parseStatement(ParseStatementInfo &Info,
return parseDirectiveErrorIfe(IDLoc, true);
case DK_ERRNZ:
return parseDirectiveErrorIfe(IDLoc, false);
case DK_RADIX:
return parseDirectiveRadix(IDLoc);
case DK_ECHO:
return parseDirectiveEcho();
}
@ -6349,7 +6343,6 @@ void MasmParser::initializeDirectiveKindMap() {
DirectiveKindMap[".savereg"] = DK_SAVEREG;
DirectiveKindMap[".savexmm128"] = DK_SAVEXMM128;
DirectiveKindMap[".setframe"] = DK_SETFRAME;
DirectiveKindMap[".radix"] = DK_RADIX;
// DirectiveKindMap[".altmacro"] = DK_ALTMACRO;
// DirectiveKindMap[".noaltmacro"] = DK_NOALTMACRO;
DirectiveKindMap["db"] = DK_DB;
@ -6591,22 +6584,6 @@ bool MasmParser::parseDirectiveMSAlign(SMLoc IDLoc, ParseStatementInfo &Info) {
return false;
}
bool MasmParser::parseDirectiveRadix(SMLoc DirectiveLoc) {
const SMLoc Loc = getLexer().getLoc();
StringRef RadixString = parseStringToEndOfStatement().trim();
unsigned Radix;
if (RadixString.getAsInteger(10, Radix)) {
return Error(Loc,
"radix must be a decimal number in the range 2 to 16; was " +
RadixString);
}
if (Radix < 2 || Radix > 16)
return Error(Loc, "radix must be in the range 2 to 16; was " +
std::to_string(Radix));
getLexer().setDefaultRadix(Radix);
return false;
}
bool MasmParser::parseDirectiveEcho() {
StringRef Message = parseStringToEndOfStatement();
Lex(); // eat end of statement

3
llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp
View File

@ -1662,9 +1662,6 @@ bool X86AsmParser::ParseIntelExpression(IntelExprStateMachine &SM, SMLoc &End) {
if ((Done = SM.isValidEndState()))
break;
return Error(Tok.getLoc(), "unknown token in expression");
case AsmToken::Error:
return Error(getLexer().getErrLoc(), getLexer().getErr());
break;
case AsmToken::EndOfStatement:
Done = true;
break;

97
llvm/test/tools/llvm-ml/radix.test
View File

@ -1,97 +0,0 @@
# RUN: llvm-ml -filetype=asm %s | FileCheck %s
.code
t1:
mov eax, 100b
mov eax, 100y
; CHECK-LABEL: t1:
; CHECK-NEXT: mov eax, 4
; CHECK-NEXT: mov eax, 4
t2:
mov eax, 100o
mov eax, 100q
; CHECK-LABEL: t2:
; CHECK-NEXT: mov eax, 64
; CHECK-NEXT: mov eax, 64
t3:
mov eax, 100d
mov eax, 100t
; CHECK-LABEL: t3:
; CHECK-NEXT: mov eax, 100
; CHECK-NEXT: mov eax, 100
t4:
mov eax, 100h
; CHECK-LABEL: t4:
; CHECK-NEXT: mov eax, 256
t5:
mov eax, 100
.radix 2
mov eax, 100
.radix 16
mov eax, 100
.radix 10
mov eax, 100
; CHECK-LABEL: t5:
; CHECK: mov eax, 100
; CHECK: mov eax, 4
; CHECK: mov eax, 256
; CHECK: mov eax, 100
t6:
.radix 9
mov eax, 100
.radix 10
; CHECK-LABEL: t6:
; CHECK: mov eax, 81
t7:
.radix 12
mov eax, 100b
mov eax, 100y
.radix 10
; CHECK-LABEL: t7:
; CHECK: mov eax, 1739
; CHECK: mov eax, 4
t8:
.radix 16
mov eax, 100d
mov eax, 100t
.radix 10
; CHECK-LABEL: t8:
; CHECK: mov eax, 4109
; CHECK: mov eax, 100
t9:
.radix 12
mov eax, 102b
.radix 16
mov eax, 10fd
.radix 10
; CHECK-LABEL: t9:
; CHECK: mov eax, 1763
; CHECK: mov eax, 4349
t10:
.radix 16
mov eax, 1e1
.radix 10
; CHECK-LABEL: t10:
; CHECK: mov eax, 481
END

60
llvm/test/tools/llvm-ml/radix_errors.test
View File

@ -1,60 +0,0 @@
; RUN: not llvm-ml -filetype=asm %s 2>&1 | FileCheck %s
.code
t1:
mov eax, 120b
mov eax, 120y
.radix 11
mov eax, 120b
mov eax, 120y
.radix 10
; CHECK: error: invalid decimal number
; CHECK: error: invalid binary number
; CHECK: error: invalid base-11 number
; CHECK: error: invalid binary number
t2:
mov eax, 190o
mov eax, 190q
.radix 13
mov eax, 190o
mov eax, 190q
.radix 10
; CHECK: error: invalid octal number
; CHECK: error: invalid octal number
; CHECK: error: invalid octal number
; CHECK: error: invalid octal number
t3:
mov eax, 1f0d
mov eax, 1f0t
.radix 13
mov eax, 1f0d
mov eax, 1f0t
.radix 10
; CHECK: error: invalid decimal number
; CHECK: error: invalid decimal number
; CHECK: error: invalid base-13 number
; CHECK: error: invalid decimal number
t4:
mov eax, 10e
.radix 16
.radix 10
mov eax, 10e
; CHECK: error: invalid decimal number
; CHECK: error: invalid decimal number
t5:
.radix 9
mov eax, 9
.radix 10
; CHECK: error: invalid base-9 number
END