[ms] [llvm-ml] Add basic support for SEH, including PROC FRAME

[epastor]

Summary

Add basic support for SEH, including PROC FRAME

[epastor]

Sync to HEAD

[epastor]

Rebase on parent

[epastor]

Rebase on parent

[epastor]

Rebase on parent

[epastor]

Rebase to HEAD

llvm/lib/MC/MCParser/COFFMasmParser.cpp

bool ParseSectionSwitch(StringRef Section, unsigned Characteristics,
                           COFF::COMDATType Type);
 
   bool ParseDirectiveProc(StringRef, SMLoc);
   bool ParseDirectiveEndProc(StringRef, SMLoc);
   bool ParseDirectiveSegment(StringRef, SMLoc);
   bool ParseDirectiveSegmentEnd(StringRef, SMLoc);
   bool ParseDirectiveIncludelib(StringRef, SMLoc);
 
+  bool ParseSEHDirectiveAllocStack(StringRef, SMLoc);
+  bool ParseSEHDirectiveEndProlog(StringRef, SMLoc);
+
   bool IgnoreDirective(StringRef, SMLoc) {
     while (!getLexer().is(AsmToken::EndOfStatement)) {
       Lex();
     }
     return false;
   }
 
   void Initialize(MCAsmParser &Parser) override {
     // Call the base implementation.
     MCAsmParserExtension::Initialize(Parser);
 
     // x64 directives
-    // .allocstack
-    // .endprolog
-    // .pushframe
-    // .pushreg
-    // .savereg
-    // .savexmm128
-    // .setframe
+    addDirectiveHandler<&COFFMasmParser::ParseSEHDirectiveAllocStack>(
+        ".allocstack");
+    addDirectiveHandler<&COFFMasmParser::ParseSEHDirectiveEndProlog>(
+        ".endprolog");
 
     // Code label directives
     // label
     // org
 
     // Conditional control flow directives
     // .break
     // .continue
     // .else
     // .elseif
     // .endif
     // .endw
     // .if
     // .repeat
     // .until
     // .untilcxz
     // .while
 
     // Data allocation directives
     // align
-    // byte/sbyte
-    // dword/sdword
     // even
-    // fword
-    // qword
-    // real4
-    // real8
+    // mmword
     // real10
     // tbyte
-    // word/sword
+    // xmmword
+    // ymmword
 
     // Listing control directives
     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".cref");
     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".list");
     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".listall");
     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".listif");
     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".listmacro");
     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".listmacroall");
void Initialize(MCAsmParser &Parser) override {
     // purge
 
     // Miscellaneous directives
     // alias
     // assume
     // .fpo
     addDirectiveHandler<&COFFMasmParser::ParseDirectiveIncludelib>(
         "includelib");
-    // mmword
     // option
     // popcontext
     // pushcontext
     // .radix
     // .safeseh
-    // xmmword
-    // ymmword
 
     // Procedure directives
     addDirectiveHandler<&COFFMasmParser::ParseDirectiveEndProc>("endp");
     // invoke (32-bit only)
     addDirectiveHandler<&COFFMasmParser::ParseDirectiveProc>("proc");
     // proto
 
-    // Processor directives
+    // Processor directives; all ignored
     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".386");
     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".386P");
     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".387");
     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".486");
     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".486P");
     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".586");
     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".586P");
     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".686");
void Initialize(MCAsmParser &Parser) override {
 
     // String directives, written <name> <directive> <params>
     // catstr (equivalent to <name> TEXTEQU <params>)
     // instr (equivalent to <name> = @InStr(<params>))
     // sizestr (equivalent to <name> = @SizeStr(<params>))
     // substr (equivalent to <name> TEXTEQU @SubStr(<params>))
 
     // Structure and record directives
-    // ends
     // record
-    // struct
     // typedef
-    // union
   }
 
   bool ParseSectionDirectiveCode(StringRef, SMLoc) {
     return ParseSectionSwitch(".text",
                               COFF::IMAGE_SCN_CNT_CODE
                             | COFF::IMAGE_SCN_MEM_EXECUTE
                             | COFF::IMAGE_SCN_MEM_READ,
                               SectionKind::getText());
bool ParseSectionDirectiveUninitializedData(StringRef, SMLoc) {
     return ParseSectionSwitch(".bss",
                               COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA
                             | COFF::IMAGE_SCN_MEM_READ
                             | COFF::IMAGE_SCN_MEM_WRITE,
                               SectionKind::getBSS());
   }
 
   StringRef CurrentProcedure;
+  bool CurrentProcedureFramed;
 
 public:
   COFFMasmParser() = default;
 };
 
 } // end anonymous namespace.
 
 static SectionKind computeSectionKind(unsigned Flags) {
bool COFFMasmParser::ParseDirectiveProc(StringRef Directive, SMLoc Loc) {
   MCSymbol *Sym = getContext().getOrCreateSymbol(Label);
 
   // Define symbol as simple function
   getStreamer().BeginCOFFSymbolDef(Sym);
   getStreamer().EmitCOFFSymbolStorageClass(2);
   getStreamer().EmitCOFFSymbolType(0x20);
   getStreamer().EndCOFFSymbolDef();
 
+  bool Framed = false;
+  if (getLexer().is(AsmToken::Identifier) &&
+      getTok().getString().equals_lower("frame")) {
+    Lex();
+    Framed = true;
+    getStreamer().EmitWinCFIStartProc(Sym, Loc);
+  }
   getStreamer().emitLabel(Sym, Loc);
+
   CurrentProcedure = Label;
+  CurrentProcedureFramed = Framed;
   return false;
 }
 bool COFFMasmParser::ParseDirectiveEndProc(StringRef Directive, SMLoc Loc) {
   StringRef Label;
   SMLoc LabelLoc = getTok().getLoc();
   if (getParser().parseIdentifier(Label))
     return Error(LabelLoc, "expected identifier for procedure end");
 
   if (CurrentProcedure.empty())
     return Error(Loc, "endp outside of procedure block");
   else if (CurrentProcedure != Label)
     return Error(LabelLoc, "endp does not match current procedure '" +
                                CurrentProcedure + "'");
+
+  if (CurrentProcedureFramed) {
+    getStreamer().EmitWinCFIEndProc(Loc);
+  }
+  CurrentProcedure = "";
+  CurrentProcedureFramed = false;
+  return false;
+}
+
+bool COFFMasmParser::ParseSEHDirectiveAllocStack(StringRef Directive,
+                                                 SMLoc Loc) {
+  int64_t Size;
+  SMLoc SizeLoc = getTok().getLoc();
+  if (getParser().parseAbsoluteExpression(Size))
+    return Error(SizeLoc, "expected integer size");
+  if (Size % 8 != 0)
+    return Error(SizeLoc, "stack size must be a multiple of 8");
+  getStreamer().EmitWinCFIAllocStack(static_cast<unsigned>(Size), Loc);
+  return false;
+}
+
+bool COFFMasmParser::ParseSEHDirectiveEndProlog(StringRef Directive,
+                                                SMLoc Loc) {
+  getStreamer().EmitWinCFIEndProlog(Loc);
   return false;
 }
 
 namespace llvm {
 
 MCAsmParserExtension *createCOFFMasmParser() { return new COFFMasmParser; }
 
 } // end namespace llvm

llvm/lib/MC/MCParser/MasmParser.cpp

enum DirectiveKind {
     DK_ERRIDN,
     DK_ERRIDNI,
     DK_ERRE,
     DK_ERRNZ,
     DK_ECHO,
     DK_STRUCT,
     DK_UNION,
     DK_ENDS,
-    DK_END
+    DK_END,
+    DK_PUSHFRAME,
+    DK_PUSHREG,
+    DK_SAVEREG,
+    DK_SAVEXMM128,
+    DK_SETFRAME,
   };
 
   /// Maps directive name --> DirectiveKind enum, for directives parsed by this
   /// class.
   StringMap<DirectiveKind> DirectiveKindMap;
 
   // Codeview def_range type parsing.
   enum CVDefRangeType {
void MasmParser::initializeDirectiveKindMap() {
   DirectiveKindMap[".errdef"] = DK_ERRDEF;
   DirectiveKindMap[".errndef"] = DK_ERRNDEF;
   DirectiveKindMap[".errdif"] = DK_ERRDIF;
   DirectiveKindMap[".errdifi"] = DK_ERRDIFI;
   DirectiveKindMap[".erridn"] = DK_ERRIDN;
   DirectiveKindMap[".erridni"] = DK_ERRIDNI;
   DirectiveKindMap[".erre"] = DK_ERRE;
   DirectiveKindMap[".errnz"] = DK_ERRNZ;
+  DirectiveKindMap[".pushframe"] = DK_PUSHFRAME;
+  DirectiveKindMap[".pushreg"] = DK_PUSHREG;
+  DirectiveKindMap[".savereg"] = DK_SAVEREG;
+  DirectiveKindMap[".savexmm128"] = DK_SAVEXMM128;
+  DirectiveKindMap[".setframe"] = DK_SETFRAME;
   // DirectiveKindMap[".altmacro"] = DK_ALTMACRO;
   // DirectiveKindMap[".noaltmacro"] = DK_NOALTMACRO;
   DirectiveKindMap["db"] = DK_DB;
   DirectiveKindMap["dd"] = DK_DD;
   DirectiveKindMap["dq"] = DK_DQ;
   DirectiveKindMap["dw"] = DK_DW;
   DirectiveKindMap["echo"] = DK_ECHO;
   DirectiveKindMap["struc"] = DK_STRUCT;

llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp

bool X86AsmParser::ParseDirective(AsmToken DirectiveID) {
   else if (IDVal == ".cv_fpo_stackalloc")
     return parseDirectiveFPOStackAlloc(DirectiveID.getLoc());
   else if (IDVal == ".cv_fpo_stackalign")
     return parseDirectiveFPOStackAlign(DirectiveID.getLoc());
   else if (IDVal == ".cv_fpo_endprologue")
     return parseDirectiveFPOEndPrologue(DirectiveID.getLoc());
   else if (IDVal == ".cv_fpo_endproc")
     return parseDirectiveFPOEndProc(DirectiveID.getLoc());
-  else if (IDVal == ".seh_pushreg")
+  else if (IDVal == ".seh_pushreg" ||
+           (Parser.isParsingMasm() && IDVal.equals_lower(".pushreg")))
     return parseDirectiveSEHPushReg(DirectiveID.getLoc());
-  else if (IDVal == ".seh_setframe")
+  else if (IDVal == ".seh_setframe" ||
+           (Parser.isParsingMasm() && IDVal.equals_lower(".setframe")))
     return parseDirectiveSEHSetFrame(DirectiveID.getLoc());
-  else if (IDVal == ".seh_savereg")
+  else if (IDVal == ".seh_savereg" ||
+           (Parser.isParsingMasm() && IDVal.equals_lower(".savereg")))
     return parseDirectiveSEHSaveReg(DirectiveID.getLoc());
-  else if (IDVal == ".seh_savexmm")
+  else if (IDVal == ".seh_savexmm" ||
+           (Parser.isParsingMasm() && IDVal.equals_lower(".savexmm128")))
     return parseDirectiveSEHSaveXMM(DirectiveID.getLoc());
-  else if (IDVal == ".seh_pushframe")
+  else if (IDVal == ".seh_pushframe" ||
+           (Parser.isParsingMasm() && IDVal.equals_lower(".pushframe")))
     return parseDirectiveSEHPushFrame(DirectiveID.getLoc());
 
   return true;
 }
 
 bool X86AsmParser::parseDirectiveArch() {
   // Ignore .arch for now.
   getParser().parseStringToEndOfStatement();

llvm/test/tools/llvm-ml/proc.test

+# RUN: llvm-ml -m32 -filetype=asm %s | FileCheck %s
+# RUN: llvm-ml -m64 -filetype=asm %s | FileCheck %s
+
+.code
+
+t1 PROC
+  ret
+t1 ENDP
+
+; CHECK: .def t1
+; CHECK-NEXT: .scl 2
+; CHECK-NEXT: .type 32
+; CHECK-NEXT: .endef
+
+; CHECK: t1:
+; CHECK: ret
+
+END

llvm/test/tools/llvm-ml/proc_frame.test

+# RUN: llvm-ml -m64 -filetype=asm %s | FileCheck %s
+
+.code
+
+t1 PROC FRAME
+  push rbp
+  .pushreg rbp
+  mov rbp, rsp
+  .setframe rbp, 0
+  pushfq
+  .allocstack 8
+  .endprolog
+  ret
+t1 ENDP
+
+; CHECK: .def t1
+; CHECK-NEXT: .scl 2
+; CHECK-NEXT: .type 32
+; CHECK-NEXT: .endef
+
+; CHECK: .seh_proc t1
+
+; CHECK: t1:
+; CHECK: push rbp
+; CHECK: .seh_pushreg rbp
+; CHECK: mov rbp, rsp
+; CHECK: .seh_setframe rbp, 0
+; CHECK: pushfq
+; CHECK: .seh_stackalloc 8
+; CHECK: .seh_endprologue
+; CHECK: ret
+; CHECK: .seh_endproc
+
+END