[ms] [llvm-ml] Add support for bitwise named operators (AND, NOT, OR) in MASM

[epastor]

Summary

Add support for bitwise named operators (AND, NOT, OR) in MASM.

Also move valid-section checking to where it's actually required.

[epastor]

Rebase on parent

[epastor]

Rebase on parent

[epastor]

Rebase to HEAD

[epastor]

Abandoning as redundant.

llvm/lib/MC/MCParser/MasmParser.cpp

 }
 
 /// Parse all binary operators with precedence >= 'Precedence'.
 /// Res contains the LHS of the expression on input.
 bool MasmParser::parseBinOpRHS(unsigned Precedence, const MCExpr *&Res,
                                SMLoc &EndLoc) {
   SMLoc StartLoc = Lexer.getLoc();
   while (true) {
+    AsmToken::TokenKind TokKind = Lexer.getKind();
+    if (Lexer.getKind() == AsmToken::Identifier) {
+      StringRef Identifier = Lexer.getTok().getString();
+      if (Identifier.equals_lower("and"))
+        TokKind = AsmToken::Amp;
+      else if (Identifier.equals_lower("not"))
+        TokKind = AsmToken::Exclaim;
+      else if (Identifier.equals_lower("or"))
+        TokKind = AsmToken::Pipe;
+    }
     MCBinaryExpr::Opcode Kind = MCBinaryExpr::Add;
-    unsigned TokPrec = getBinOpPrecedence(Lexer.getKind(), Kind);
+    unsigned TokPrec = getBinOpPrecedence(TokKind, Kind);
 
     // If the next token is lower precedence than we are allowed to eat, return
     // successfully with what we ate already.
     if (TokPrec < Precedence)
       return false;
 
     Lex();
 
if (Size == 1) {
       uint64_t IntValue = 0;
       for (const unsigned char CharVal : Value.bytes())
         IntValue = (IntValue << 8) | CharVal;
       Values.push_back(MCConstantExpr::create(IntValue, getContext()));
     }
     Lex();
   } else {
     const MCExpr *Value;
-    if (checkForValidSection() || parseExpression(Value))
+    if (parseExpression(Value))
       return true;
     if (getTok().is(AsmToken::Identifier) &&
         getTok().getString().equals_lower("dup")) {
       Lex(); // Eat 'dup'.
       const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value);
       if (!MCE)
         return Error(Value->getLoc(),
                      "cannot repeat value a non-constant number of times");
while (getTok().isNot(EndToken) ||
     parseOptionalToken(AsmToken::EndOfStatement);
   }
 
   return false;
 }
 
 // Initialize real data values.
 bool MasmParser::emitRealValues(const fltSemantics &Semantics) {
+  if (checkForValidSection())
+    return true;
+
   SmallVector<APInt, 1> ValuesAsInt;
   if (parseRealInstList(Semantics, ValuesAsInt))
     return true;
 
   for (const APInt &AsInt : ValuesAsInt) {
     getStreamer().emitIntValue(AsInt.getLimitedValue(),
                                AsInt.getBitWidth() / 8);
   }
   return false;
 }
 
 // Add a real field to the current struct.
 bool MasmParser::addRealField(StringRef Name, const fltSemantics &Semantics) {
   StructInfo &Struct = StructInProgress.back();
   FieldInfo &Field = Struct.addField(Name, FT_REAL);
   RealFieldInfo &RealInfo = Field.Contents.RealInfo;
 
   Field.SizeOf = 0;
 
-  if (checkForValidSection() ||
-      parseRealInstList(Semantics, RealInfo.AsIntValues))
+  if (parseRealInstList(Semantics, RealInfo.AsIntValues))
     return true;
 
   Field.Type = RealInfo.AsIntValues.back().getBitWidth() / 8;
   Field.LengthOf = RealInfo.AsIntValues.size();
   Field.SizeOf = Field.Type * Field.LengthOf;
   if (Struct.IsUnion)
     Struct.Size = std::max(Struct.Size, Field.SizeOf);
   else
     Struct.Size += Field.SizeOf;
   return false;
 }
 
 /// parseDirectiveRealValue
 ///  ::= (real4 | real8) [ expression (, expression)* ]
 bool MasmParser::parseDirectiveRealValue(StringRef IDVal,
                                          const fltSemantics &Semantics) {
-  if (checkForValidSection())
-    return true;
-
   if (StructInProgress.empty()) {
     // Initialize data value.
     if (emitRealValues(Semantics))
       return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
   } else if (addRealField("", Semantics)) {
     return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
   }
   return false;
 }
 
 /// parseDirectiveNamedRealValue
 ///  ::= name (real4 | real8) [ expression (, expression)* ]
 bool MasmParser::parseDirectiveNamedRealValue(StringRef IDVal,
                                               const fltSemantics &Semantics,
                                               StringRef Name, SMLoc NameLoc) {
-  if (checkForValidSection())
-    return true;
-
   if (StructInProgress.empty()) {
     // Initialize named data value.
     MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
     getStreamer().emitLabel(Sym);
     if (emitRealValues(Semantics))
       return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
   } else if (addRealField(Name, Semantics)) {
     return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");