[ms] [llvm-ml] Add initial MASM STRUCT/UNION support

[epastor]

Summary

Add support for user-defined types to MasmParser, including initialization and field access.

Known issues:

• Omitted entry initializers (e.g., <,0>) do not work consistently for nested structs/arrays.
• Size checking/inference for values with known types is not yet implemented.
• Some ml64.exe syntaxes for accessing STRUCT fields are not recognized.
  • [<register>.<struct name>].<field>
  • [<register>[<struct name>.<field>]]
  • (<struct name> PTR [<register>]).<field>
  • [<variable>.<struct name>].<field>
  • (<struct name> PTR <variable>).<field>

[epastor]

Switch away from std::variant to allow compilation without C++17

[epastor]

Address remaining C++17-only usage (non-void emplace_back), and fix clang-tidy errors.

[epastor]

Formatting fixup

[epastor]

Rebasing to HEAD

[rnk]

llvm/lib/MC/MCParser/MasmParser.cpp

167

I think this union is creating a fair amount of code complexity. The more clang-y code pattern would be to do something like:

• Use a BumpPtrAllocator for memory allocation to make these all owned by the asm parser, there should be one already somewhere
• Use raw pointers to point between these classes, avoids need for unique_ptr or other ownership management
• Set up the usual class hierarchy: class FieldInitializer { FieldType FT; ... }; class IntFieldInit : public FieldInitializer { ... }; class RealFieldInit : public FieldInitializer { ... }; class StructFieldInit : public FieldInitializer { ... };

Then the parseFieldInitializer variants could return a nullable pointer to indicate parsing success or failure. WDYT?

The drawback of this approach is that objects in BumpPtrAllocators are not destroyed, so they cannot own external resources. Most vectors can just become ArrayRefs pointing to arrays in the same allocator. The main thing I see that this would affect is the StringMap for fields and APInt for int fields. So, I guess I'm not sure it's worth a big rewrite, but it's something to consider.

[epastor]

llvm/lib/MC/MCParser/MasmParser.cpp

167

I agree it would might be worth the change - but the rewrite looks to be pretty big, and complicated due to several of the members in these objects. Let's move forward in a full review for now, and discuss the right answer as we go.

[epastor]

Rebase to HEAD

[thakis]

Sorry it took a while. This is a good chunk of work, thanks for doing it. Smaller changes are faster to review :)

As a general point, before sending out a change I'd suggest doing a detailed read by yourself to find things like typos in comments, notice things like needless duplication (sometimes, it's the right tradeoff), etc.

llvm/include/llvm/MC/MCParser/MCAsmParser.h

173

nit: LookUpFieldOffset. "Lookup" is a noun, "look up" is the verb.

llvm/lib/MC/MCParser/MasmParser.cpp

116

Can you add comments what each means? Since REAL is an APInt below, I guess it's also an integer type?

123

Should this be a SmallVector?

(The clang approach would probably to allocate field infos right after the struct info so that it's in one slab, but probably not worth it here.)

167

Sounds good to me, but maybe add a FIXME with rnk's suggestion.

211

s/integral values/struct values/

...but why pass in a FieldType at all if only one value is valid? Why not just

FieldInitializer(SmallVector<const MCExpr *, 1> &&Values) : FT(FT_INTEGRAL) {
  new (&IntInfo) IntFieldInfo(Values);
}

?

219

same

225

same

233

same

357

can you use llvm::alignTo() for this?

403

sentence case

406

same

3527

This is identical to the else you added in the previous function as far as I can tell. Can you change this to be less copy-pasty? (extract function, or make one of the two dispatch to the other, or what have you)

3540

this is very nested. maybe try this structure:

if lcurly
  return parseFieldInitializerCurly()
if less
  return parseFieldInitializeLess
if ...

i.e. add helper functions, with comments. If you find yourself at nesting depth 6, that's often a sign that extracting a function might be a good idea. I find "every part of a function should be at the same level of abstraction" a good rule of thumb fairly often.

3605

This looks very similar to the previous function.
extract the common stuff into helper functions.

3669

same

llvm/test/tools/llvm-ml/struct.test

9

can you use some variation in keyword and identifier case to add test coverage for this all being case-insensitive?

[epastor]

Address comments; details in inline responses.

[epastor]

In D75306#2018313, @thakis wrote:

Sorry it took a while. This is a good chunk of work, thanks for doing it. Smaller changes are faster to review :)

As a general point, before sending out a change I'd suggest doing a detailed read by yourself to find things like typos in comments, notice things like needless duplication (sometimes, it's the right tradeoff), etc.

With apologies... I did do a detailed read. I didn't spot the things you did. I suppose that's what review is for, right?

[epastor]

llvm/include/llvm/MC/MCParser/MCAsmParser.h

173

Changed. However... there are several functions in other files that use "lookup" rather than "lookUp" in a verb context. I'd been trying to match those.

llvm/lib/MC/MCParser/MasmParser.cpp

123

It can't be a SmallVector, since FieldInfo is an incomplete type.

211

Good point; fixed!

357

That is EXTREMELY useful, and I didn't realize it existed! Thanks!

3527

Thanks for highlighting this; I'd missed an easy way to clean up the repetition.

3540

Thank you very much for highlighting this. I'd been very aware of it as a problem at the time, but failed to find a good way to clean it up. With your prompting and fresh eyes, I've been able to find a much cleaner approach.

[epastor]

Rebase against HEAD

[thakis]

Sorry, I looked through this a while ago but forgot to hit "Submit" :(

This is looking pretty good. Only the test coverage / LengthOf==1 questions below left really.

It's weird that both parsing and emission are in the same (giant) class, but that's not new at least.

llvm/include/llvm/MC/MCParser/MCAsmParser.h

173

Ah, local consistency is a good reason. No need to change it next time when I say something like that (but no need to change it back either)

llvm/lib/MC/MCParser/MasmParser.cpp

320

could you add comments what Type and LengthOf mean? Offset and SizeOf are self-explanatory, I can guess at LengthOf, but Type makes me come up empty.

3343

This is again identical to the added block in the previous function; extract a addFieldToCurrentStruct(IdVal, Size) or addIntegralField (for consistency with the Real version below) function. (Is Name / NameLocnot used here in the StructInProgress case?)

3624

We're in a LengthOf == 1 block. How could we hit this? Does anything in here modify Field?

3631

We're in a LengthOf == 1 block. How could we hit this? Does anything in here modify Field?

3687

What if it's something else? This is user-controlled and could have arbitrary contents, no?

[epastor]

Addressing feedback, and rebasing to HEAD.

[epastor]

llvm/lib/MC/MCParser/MasmParser.cpp

3343

Good point. Done.

3624

Sorry, copy/paste error. Fixed.

3687

Yes, but in that case parseToken() will correctly fail due to not finding LessGreater... in which case we'll return "true" to pass the error upwards.

parseToken() is an imperative and returns true if it fails, unlike parseOptionalToken() which is an attempt and returns true if it succeeds.

[thakis]

Thanks, the code looks close to done to me now. Can you add a tests that covers most of the error cases as well?

llvm/lib/MC/MCParser/MasmParser.cpp

3323

.

3457

.

…also in many other places. curl https://reviews.llvm.org/file/data/mrzekpri33kb4kddo3tr/PHID-FILE-ejca6nujwdhbsxqgces2/D75306.diff | grep '^\+.*// [A-Z].*[^.]$' shows some of them.

3698

llvm style says no else after return/continue/break (https://llvm.org/docs/CodingStandards.html#use-early-exits-and-continue-to-simplify-code) (just put the else's body's contents right after the if and dedent)

[epastor]

Rebase to HEAD

[epastor]

Improve error handling and add tests

Also fix comment formatting, and address other feedback.

[epastor]

Thanks, Nico! I've added test coverage for many (most?) of the error cases as well.

[thakis]

llvm/test/tools/llvm-ml/struct_errors.test

10 ↗

(On Diff #275719)

This diag could probably add "expected at most %d elements, got %d" at the end

48 ↗

(On Diff #275719)

this could maybe say "alignment must be power of two, got %d" or similar (I realize it's an existing diag)

[epastor]

Improve error messages and fix a missing OnFailure case

[uabelho]

llvm/lib/MC/MCParser/MasmParser.cpp

3675

gcc (7.4.0) warns with
../lib/MC/MCParser/MasmParser.cpp:3676:1: warning: control reaches end of non-void function [-Wreturn-type]
here.
It can be silenced with an llvm_unreachable if that's acceptable.

3828

gcc 7.4.0 warning here too
../lib/MC/MCParser/MasmParser.cpp:3829:1: warning: control reaches end of non-void function [-Wreturn-type]

3830

gcc warns that this method is unused. Will it be used or can it perhaps be removed?

3907

gcc 7.4.0 warning here too
../lib/MC/MCParser/MasmParser.cpp:3908:1: warning: control reaches end of non-void function [-Wreturn-type]

llvm/include/llvm/MC/MCParser/MCAsmParser.h

public:
   /// Run the parser on the input source buffer.
   virtual bool Run(bool NoInitialTextSection, bool NoFinalize = false) = 0;
 
   virtual void setParsingMSInlineAsm(bool V) = 0;
   virtual bool isParsingMSInlineAsm() = 0;
 
   virtual bool isParsingMasm() const { return false; }
 
+  virtual bool LookupFieldOffset(StringRef Base, StringRef Member,
+                                 unsigned &Offset) {
+    return true;
+  }
+
   /// Parse MS-style inline assembly.
   virtual bool parseMSInlineAsm(
       void *AsmLoc, std::string &AsmString, unsigned &NumOutputs,
       unsigned &NumInputs, SmallVectorImpl<std::pair<void *, bool>> &OpDecls,
       SmallVectorImpl<std::string> &Constraints,
       SmallVectorImpl<std::string> &Clobbers, const MCInstrInfo *MII,
       const MCInstPrinter *IP, MCAsmParserSemaCallback &SI) = 0;
 

llvm/include/llvm/MC/MCParser/MCTargetAsmParser.h

protected: // Can only create subclasses.
   /// AvailableFeatures - The current set of available features.
   FeatureBitset AvailableFeatures;
 
   /// ParsingMSInlineAsm - Are we parsing ms-style inline assembly?
   bool ParsingMSInlineAsm = false;
 
   /// SemaCallback - The Sema callback implementation.  Must be set when parsing
   /// ms-style inline assembly.
-  MCAsmParserSemaCallback *SemaCallback;
+  MCAsmParserSemaCallback *SemaCallback = nullptr;
 
   /// Set of options which affects instrumentation of inline assembly.
   MCTargetOptions MCOptions;
 
   /// Current STI.
   const MCSubtargetInfo *STI;
 
   const MCInstrInfo &MII;

llvm/lib/MC/MCParser/MasmParser.cpp

struct ParseStatementInfo {
 
   SmallVectorImpl<AsmRewrite> *AsmRewrites = nullptr;
 
   ParseStatementInfo() = delete;
   ParseStatementInfo(SmallVectorImpl<AsmRewrite> *rewrites)
       : AsmRewrites(rewrites) {}
 };
 
+enum FieldType { FT_INTEGRAL, FT_REAL, FT_STRUCT };
+struct FieldInfo;
+struct StructInfo {
+  StringRef Name;
+  bool IsUnion = false;
+  size_t Alignment = 0;
+  size_t Size = 0;
+  std::vector<FieldInfo> Fields;
+  StringMap<size_t> FieldsByName;
+
+  FieldInfo &addField(StringRef FieldName, FieldType FT);
+
+  StructInfo() = default;
+
+  StructInfo(StringRef StructName, bool Union, unsigned AlignmentValue)
+      : Name(StructName), IsUnion(Union), Alignment(AlignmentValue) {}
+};
+
+struct StructInitializer;
+struct IntFieldInfo {
+  SmallVector<const MCExpr *, 1> Values;
+
+  IntFieldInfo() = default;
+  IntFieldInfo(const SmallVector<const MCExpr *, 1> &V) { Values = V; }
+  IntFieldInfo(SmallVector<const MCExpr *, 1> &&V) { Values = V; }
+};
+struct RealFieldInfo {
+  SmallVector<APInt, 1> AsIntValues;
+
+  RealFieldInfo() = default;
+  RealFieldInfo(const SmallVector<APInt, 1> &V) { AsIntValues = V; }
+  RealFieldInfo(SmallVector<APInt, 1> &&V) { AsIntValues = V; }
+};
+struct StructFieldInfo {
+  std::vector<StructInitializer> Initializers;
+  StructInfo Structure;
+
+  StructFieldInfo() = default;
+  StructFieldInfo(const std::vector<StructInitializer> &V, StructInfo S) {
+    Initializers = V;
+    Structure = S;
+  }
+  StructFieldInfo(std::vector<StructInitializer> &&V, StructInfo S) {
+    Initializers = V;
+    Structure = S;
+  }
+};
+
+class FieldInitializer {
+public:
+  FieldType FT;
+  union {
+    IntFieldInfo IntInfo;
+    RealFieldInfo RealInfo;
+    StructFieldInfo StructInfo;
+  };
+
+  ~FieldInitializer() {
+    switch (FT) {
+    case FT_INTEGRAL:
+      IntInfo.~IntFieldInfo();
+      break;
+    case FT_REAL:
+      RealInfo.~RealFieldInfo();
+      break;
+    case FT_STRUCT:
+      StructInfo.~StructFieldInfo();
+      break;
+    }
+  }
+
+  FieldInitializer(FieldType FT) : FT(FT) {
+    switch (FT) {
+    case FT_INTEGRAL:
+      new (&IntInfo) IntFieldInfo();
+      break;
+    case FT_REAL:
+      new (&RealInfo) RealFieldInfo();
+      break;
+    case FT_STRUCT:
+      new (&StructInfo) StructFieldInfo();
+      break;
+    }
+  }
+
+  FieldInitializer(FieldType FT, SmallVector<const MCExpr *, 1> &&Values)
+      : FT(FT) {
+    switch (FT) {
+    case FT_INTEGRAL:
+      new (&IntInfo) IntFieldInfo(Values);
+      break;
+    case FT_REAL:
+      llvm_unreachable("Cannot initialize a real field with integral values");
+      break;
+    case FT_STRUCT:
+      llvm_unreachable("Cannot initialize a struct field with integral values");
+      break;
+    }
+  }
+
+  FieldInitializer(FieldType FT, SmallVector<APInt, 1> &&AsIntValues) : FT(FT) {
+    switch (FT) {
+    case FT_INTEGRAL:
+      llvm_unreachable("Cannot initialize an integral field with real values");
+      break;
+    case FT_REAL:
+      new (&RealInfo) RealFieldInfo(AsIntValues);
+      break;
+    case FT_STRUCT:
+      llvm_unreachable("Cannot initialize a struct field with real values");
+      break;
+    }
+  }
+
+  FieldInitializer(FieldType FT, std::vector<StructInitializer> &&Initializers,
+                   struct StructInfo Structure)
+      : FT(FT) {
+    switch (FT) {
+    case FT_INTEGRAL:
+      llvm_unreachable(
+          "Cannot initialize an integral field with struct values");
+      break;
+    case FT_REAL:
+      llvm_unreachable("Cannot initialize a real field with struct values");
+      break;
+    case FT_STRUCT:
+      new (&StructInfo) StructFieldInfo(Initializers, Structure);
+      break;
+    }
+  }
+
+  FieldInitializer(const FieldInitializer &Initializer) : FT(Initializer.FT) {
+    switch (FT) {
+    case FT_INTEGRAL:
+      new (&IntInfo) IntFieldInfo(Initializer.IntInfo);
+      break;
+    case FT_REAL:
+      new (&RealInfo) RealFieldInfo(Initializer.RealInfo);
+      break;
+    case FT_STRUCT:
+      new (&StructInfo) StructFieldInfo(Initializer.StructInfo);
+      break;
+    }
+  }
+
+  FieldInitializer(FieldInitializer &&Initializer) : FT(Initializer.FT) {
+    switch (FT) {
+    case FT_INTEGRAL:
+      new (&IntInfo) IntFieldInfo(Initializer.IntInfo);
+      break;
+    case FT_REAL:
+      new (&RealInfo) RealFieldInfo(Initializer.RealInfo);
+      break;
+    case FT_STRUCT:
+      new (&StructInfo) StructFieldInfo(Initializer.StructInfo);
+      break;
+    }
+  }
+
+  FieldInitializer &operator=(const FieldInitializer &Initializer) {
+    if (FT != Initializer.FT) {
+      switch (FT) {
+      case FT_INTEGRAL:
+        IntInfo.~IntFieldInfo();
+        break;
+      case FT_REAL:
+        RealInfo.~RealFieldInfo();
+        break;
+      case FT_STRUCT:
+        StructInfo.~StructFieldInfo();
+        break;
+      }
+    }
+    FT = Initializer.FT;
+    switch (FT) {
+    case FT_INTEGRAL:
+      IntInfo = Initializer.IntInfo;
+      break;
+    case FT_REAL:
+      RealInfo = Initializer.RealInfo;
+      break;
+    case FT_STRUCT:
+      StructInfo = Initializer.StructInfo;
+      break;
+    }
+    return *this;
+  }
+
+  FieldInitializer &operator=(FieldInitializer &&Initializer) {
+    if (FT != Initializer.FT) {
+      switch (FT) {
+      case FT_INTEGRAL:
+        IntInfo.~IntFieldInfo();
+        break;
+      case FT_REAL:
+        RealInfo.~RealFieldInfo();
+        break;
+      case FT_STRUCT:
+        StructInfo.~StructFieldInfo();
+        break;
+      }
+    }
+    FT = Initializer.FT;
+    switch (FT) {
+    case FT_INTEGRAL:
+      IntInfo = Initializer.IntInfo;
+      break;
+    case FT_REAL:
+      RealInfo = Initializer.RealInfo;
+      break;
+    case FT_STRUCT:
+      StructInfo = Initializer.StructInfo;
+      break;
+    }
+    return *this;
+  }
+};
+
+struct StructInitializer {
+  std::vector<FieldInitializer> FieldInitializers;
+};
+
+struct FieldInfo {
+  size_t Offset = 0;
+  size_t SizeOf = 0;
+  size_t LengthOf = 0;
+  size_t Type = 0;
+  FieldInitializer Contents;
+
+  FieldInfo(FieldType FT) : Contents(FT) {}
+};
+
+FieldInfo &StructInfo::addField(StringRef FieldName, FieldType FT) {
+  if (!FieldName.empty())
+    FieldsByName[FieldName] = Fields.size();
+  Fields.emplace_back(FT);
+  FieldInfo &Field = Fields.back();
+  if (IsUnion) {
+    Field.Offset = 0;
+  } else {
+    if (Size % Alignment != 0) {
+      Size += Alignment - (Size % Alignment);
+    }
+    Field.Offset = Size;
+  }
+  return Field;
+}
+
 /// The concrete assembly parser instance.
 // Note that this is a full MCAsmParser, not an MCAsmParserExtension!
 // It's a peer of AsmParser, not of COFFAsmParser, WasmAsmParser, etc.
 class MasmParser : public MCAsmParser {
 private:
   AsmLexer Lexer;
   MCContext &Ctx;
   MCStreamer &Out;
struct Variable {
     StringRef Name;
     bool Redefinable = true;
     bool IsText = false;
     int64_t NumericValue = 0;
     std::string TextValue;
   };
   StringMap<Variable> Variables;
 
+  /// Stack of active struct definitions.
+  SmallVector<StructInfo, 1> StructInProgress;
+
+  /// maps struct tags to struct definitions
+  StringMap<StructInfo> Structs;
+
+  /// maps data location names to user-defined types
+  StringMap<const StructInfo *> KnownType;
+
   /// Stack of active macro instantiations.
   std::vector<MacroInstantiation*> ActiveMacros;
 
   /// List of bodies of anonymous macros.
   std::deque<MCAsmMacro> MacroLikeBodies;
 
   /// Keeps track of how many .macro's have been instantiated.
   unsigned NumOfMacroInstantiations;
private:
   bool ParsingMSInlineAsm = false;
 
   /// Did we already inform the user about inconsistent MD5 usage?
   bool ReportedInconsistentMD5 = false;
 
   // Is alt macro mode enabled.
   bool AltMacroMode = false;
 
+  // Current <...> expression depth
+  unsigned AngleBracketDepth = 0U;
+
 public:
   MasmParser(SourceMgr &SM, MCContext &Ctx, MCStreamer &Out,
              const MCAsmInfo &MAI, unsigned CB);
   MasmParser(const MasmParser &) = delete;
   MasmParser &operator=(const MasmParser &) = delete;
   ~MasmParser() override;
 
   bool Run(bool NoInitialTextSection, bool NoFinalize = false) override;
void setParsingMSInlineAsm(bool V) override {
     // When parsing MS inline asm, we must lex 0b1101 and 0ABCH as binary and
     // hex integer literals.
     Lexer.setLexMasmIntegers(V);
   }
   bool isParsingMSInlineAsm() override { return ParsingMSInlineAsm; }
 
   bool isParsingMasm() const override { return true; }
 
+  bool LookupFieldOffset(StringRef Base, StringRef Member,
+                         unsigned &Offset) override;
+
   bool parseMSInlineAsm(void *AsmLoc, std::string &AsmString,
                         unsigned &NumOutputs, unsigned &NumInputs,
                         SmallVectorImpl<std::pair<void *,bool>> &OpDecls,
                         SmallVectorImpl<std::string> &Constraints,
                         SmallVectorImpl<std::string> &Clobbers,
                         const MCInstrInfo *MII, const MCInstPrinter *IP,
                         MCAsmParserSemaCallback &SI) override;
 
private:
   void printMacroInstantiations();
   void printMessage(SMLoc Loc, SourceMgr::DiagKind Kind, const Twine &Msg,
                     SMRange Range = None) const {
     ArrayRef<SMRange> Ranges(Range);
     SrcMgr.PrintMessage(Loc, Kind, Msg, Ranges);
   }
   static void DiagHandler(const SMDiagnostic &Diag, void *Context);
 
+  bool LookupFieldOffset(const StructInfo &Structure, StringRef Member,
+                         unsigned &Offset);
+
   /// Should we emit DWARF describing this assembler source?  (Returns false if
   /// the source has .file directives, which means we don't want to generate
   /// info describing the assembler source itself.)
   bool enabledGenDwarfForAssembly();
 
   /// Enter the specified file. This returns true on failure.
   bool enterIncludeFile(const std::string &Filename);
 
enum DirectiveKind {
     DK_ERRNDEF,
     DK_ERRDIF,
     DK_ERRDIFI,
     DK_ERRIDN,
     DK_ERRIDNI,
     DK_ERRE,
     DK_ERRNZ,
     DK_ECHO,
+    DK_STRUCT,
+    DK_UNION,
+    DK_ENDS,
     DK_END
   };
 
   /// Maps directive name --> DirectiveKind enum, for
   /// directives parsed by this class.
   StringMap<DirectiveKind> DirectiveKindMap;
 
   // Codeview def_range type parsing.
private:
   StringMap<CVDefRangeType> CVDefRangeTypeMap;
 
   bool parseInitValue(unsigned Size);
 
   // ".ascii", ".asciz", ".string"
   bool parseDirectiveAscii(StringRef IDVal, bool ZeroTerminated);
 
   // "byte", "word", ...
-  bool parseScalarInstList(unsigned Size,
-                           SmallVectorImpl<const MCExpr *> &Values);
+  bool emitIntValue(const MCExpr *Value, unsigned Size);
+  bool parseScalarInitializer(unsigned Size,
+                              SmallVectorImpl<const MCExpr *> &Values,
+                              unsigned StringPadLength = 0);
+  bool parseScalarInstList(
+      unsigned Size, SmallVectorImpl<const MCExpr *> &Values,
+      const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
   bool parseDirectiveValue(StringRef IDVal, unsigned Size);
   bool parseDirectiveNamedValue(StringRef IDVal, unsigned Size, StringRef Name,
                                 SMLoc NameLoc);
 
   // "real4", "real8"
   bool parseDirectiveRealValue(StringRef IDVal, const fltSemantics &Semantics);
-  bool parseRealInstList(const fltSemantics &Semantics,
-                         SmallVectorImpl<APInt> &Values);
+  bool parseRealInstList(
+      const fltSemantics &Semantics, SmallVectorImpl<APInt> &Values,
+      const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
   bool parseDirectiveNamedRealValue(StringRef IDVal,
                                     const fltSemantics &Semantics,
                                     StringRef Name, SMLoc NameLoc);
 
+  bool parseFieldInitializer(const FieldInfo &Field,
+                             FieldInitializer &Initializer);
+  bool parseFieldInitializer(const FieldInfo &Field,
+                             const IntFieldInfo &Contents,
+                             FieldInitializer &Initializer);
+  bool parseFieldInitializer(const FieldInfo &Field,
+                             const RealFieldInfo &Contents,
+                             FieldInitializer &Initializer);
+  bool parseFieldInitializer(const FieldInfo &Field,
+                             const StructFieldInfo &Contents,
+                             FieldInitializer &Initializer);
+
+  bool parseStructInitializer(const StructInfo &Structure,
+                              StructInitializer &Initializer);
+  bool parseStructInstList(
+      const StructInfo &Structure, std::vector<StructInitializer> &Initializers,
+      const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
+
+  bool emitFieldValue(const FieldInfo &Field);
+  bool emitFieldValue(const FieldInfo &Field, const IntFieldInfo &Contents);
+  bool emitFieldValue(const FieldInfo &Field, const RealFieldInfo &Contents);
+  bool emitFieldValue(const FieldInfo &Field, const StructFieldInfo &Contents);
+
+  bool emitStructValue(const StructInfo &Structure);
+
+  bool emitFieldInitializer(const FieldInfo &Field,
+                            const FieldInitializer &Initializer);
+  bool emitFieldInitializer(const FieldInfo &Field,
+                            const IntFieldInfo &Contents,
+                            const IntFieldInfo &Initializer);
+  bool emitFieldInitializer(const FieldInfo &Field,
+                            const RealFieldInfo &Contents,
+                            const RealFieldInfo &Initializer);
+  bool emitFieldInitializer(const FieldInfo &Field,
+                            const StructFieldInfo &Contents,
+                            const StructFieldInfo &Initializer);
+
+  bool emitStructInitializer(const StructInfo &Structure,
+                             const StructInitializer &Initializer);
+
+  // user-defined types (structs, unions)
+  bool emitStructValue(const StructInfo &Structure,
+                       const StructInitializer &Initializer,
+                       size_t InitialOffset = 0, size_t InitialField = 0);
+  bool parseDirectiveStructValue(const StructInfo &Structure,
+                                 StringRef Directive, SMLoc DirLoc);
+  bool parseDirectiveNamedStructValue(const StructInfo &Structure,
+                                      StringRef Directive, SMLoc DirLoc,
+                                      StringRef Name);
+
   // "=", "equ", "textequ"
   bool parseDirectiveEquate(StringRef IDVal, StringRef Name,
                             DirectiveKind DirKind);
 
   bool parseDirectiveOrg(); // ".org"
   bool parseDirectiveAlign();  // "align"
 
   // ".file", ".line", ".loc", ".stabs"
private:
   // macro directives
   bool parseDirectivePurgeMacro(SMLoc DirectiveLoc);
   bool parseDirectiveExitMacro(StringRef Directive);
   bool parseDirectiveEndMacro(StringRef Directive);
   bool parseDirectiveMacro(SMLoc DirectiveLoc);
   // alternate macro mode directives
   bool parseDirectiveAltmacro(StringRef Directive);
 
+  bool parseDirectiveStruct(StringRef Directive, DirectiveKind DirKind,
+                            StringRef Name, SMLoc NameLoc);
+  bool parseDirectiveNestedStruct(StringRef Directive, DirectiveKind DirKind);
+  bool parseDirectiveEnds(StringRef Name, SMLoc NameLoc);
+  bool parseDirectiveNestedEnds();
+
   /// Parse a directive like ".globl" which
   /// accepts a single symbol (which should be a label or an external).
   bool parseDirectiveSymbolAttribute(MCSymbolAttr Attr);
 
   bool parseDirectiveComm(bool IsLocal); // ".comm" and ".lcomm"
 
   bool parseDirectiveComment(SMLoc DirectiveLoc); // "comment"
 
if (!Split.second.empty()) {
       } else if (MAI.doesAllowAtInName() && !MAI.useParensForSymbolVariant()) {
         Variant = MCSymbolRefExpr::VK_None;
       } else {
         return Error(SMLoc::getFromPointer(Split.second.begin()),
                      "invalid variant '" + Split.second + "'");
       }
     }
 
+    // Find the field offset if used.
+    unsigned Offset = 0;
+    Split = SymbolName.split('.');
+    if (!Split.second.empty()) {
+      SymbolName = Split.first;
+      if (Structs.count(SymbolName.lower()) &&
+          !LookupFieldOffset(SymbolName, Split.second, Offset)) {
+        // This is actually a reference to a field offset.
+        Res = MCConstantExpr::create(Offset, getContext());
+        return false;
+      }
+
+      auto TypeIt = KnownType.find(SymbolName);
+      if (TypeIt == KnownType.end() ||
+          LookupFieldOffset(*TypeIt->second, Split.second, Offset)) {
+        std::pair<StringRef, StringRef> BaseMember = Split.second.split('.');
+        StringRef Base = BaseMember.first, Member = BaseMember.second;
+        LookupFieldOffset(Base, Member, Offset);
+      }
+    }
+
     MCSymbol *Sym = getContext().getInlineAsmLabel(SymbolName);
     if (!Sym)
       Sym = getContext().getOrCreateSymbol(SymbolName);
 
     // If this is an absolute variable reference, substitute it now to preserve
     // semantics in the face of reassignment.
     if (Sym->isVariable()) {
       auto V = Sym->getVariableValue(/*SetUsed*/ false);
       bool DoInline = isa<MCConstantExpr>(V) && !Variant;
       if (auto TV = dyn_cast<MCTargetExpr>(V))
         DoInline = TV->inlineAssignedExpr();
       if (DoInline) {
         if (Variant)
           return Error(EndLoc, "unexpected modifier on variable reference");
         Res = Sym->getVariableValue(/*SetUsed*/ false);
         return false;
       }
     }
 
     // Otherwise create a symbol ref.
-    Res = MCSymbolRefExpr::create(Sym, Variant, getContext(), FirstTokenLoc);
+    const MCExpr *SymRef =
+        MCSymbolRefExpr::create(Sym, Variant, getContext(), FirstTokenLoc);
+    if (Offset) {
+      Res = MCBinaryExpr::create(MCBinaryExpr::Add, SymRef,
+                                 MCConstantExpr::create(Offset, getContext()),
+                                 getContext());
+    } else {
+      Res = SymRef;
+    }
     return false;
   }
   case AsmToken::BigNum:
     return TokError("literal value out of range for directive");
   case AsmToken::Integer: {
     SMLoc Loc = getTok().getLoc();
     int64_t IntVal = getTok().getIntVal();
     Res = MCConstantExpr::create(IntVal, getContext());
bool MasmParser::parseAbsoluteExpression(int64_t &Res) {
   if (!Expr->evaluateAsAbsolute(Res, getStreamer().getAssemblerPtr()))
     return Error(StartLoc, "expected absolute expression");
 
   return false;
 }
 
 static unsigned getGNUBinOpPrecedence(AsmToken::TokenKind K,
                                       MCBinaryExpr::Opcode &Kind,
-                                      bool ShouldUseLogicalShr) {
+                                      bool ShouldUseLogicalShr,
+                                      bool EndExpressionAtGreater) {
   switch (K) {
   default:
     return 0; // not a binop.
 
   // Lowest Precedence: &&, ||
   case AsmToken::AmpAmp:
     Kind = MCBinaryExpr::LAnd;
     return 2;
case AsmToken::LessGreater:
     return 3;
   case AsmToken::Less:
     Kind = MCBinaryExpr::LT;
     return 3;
   case AsmToken::LessEqual:
     Kind = MCBinaryExpr::LTE;
     return 3;
   case AsmToken::Greater:
+    if (EndExpressionAtGreater)
+      return 0;
     Kind = MCBinaryExpr::GT;
     return 3;
   case AsmToken::GreaterEqual:
     Kind = MCBinaryExpr::GTE;
     return 3;
 
   // Low Intermediate Precedence: +, -
   case AsmToken::Plus:
case AsmToken::Slash:
     return 6;
   case AsmToken::Percent:
     Kind = MCBinaryExpr::Mod;
     return 6;
   case AsmToken::LessLess:
     Kind = MCBinaryExpr::Shl;
     return 6;
   case AsmToken::GreaterGreater:
+    if (EndExpressionAtGreater)
+      return 0;
     Kind = ShouldUseLogicalShr ? MCBinaryExpr::LShr : MCBinaryExpr::AShr;
     return 6;
   }
 }
 
 unsigned MasmParser::getBinOpPrecedence(AsmToken::TokenKind K,
                                         MCBinaryExpr::Opcode &Kind) {
   bool ShouldUseLogicalShr = MAI.shouldUseLogicalShr();
-  return getGNUBinOpPrecedence(K, Kind, ShouldUseLogicalShr);
+  return getGNUBinOpPrecedence(K, Kind, ShouldUseLogicalShr,
+                               AngleBracketDepth > 0);
 }
 
 /// 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) {
if (DirKind != DK_NO_DIRECTIVE) {
     //    specific or may potentially behave differently on certain targets.
     // 3. The generic directive parser implemented by this class. These are
     //    all the directives that behave in a target and platform independent
     //    manner, or at least have a default behavior that's shared between
     //    all targets and platforms.
 
     getTargetParser().flushPendingInstructions(getStreamer());
 
+    // Special-case handling of structure-end directives at higher priority,
+    // since ENDS is overloaded as a segment-end directive.
+    if (IDVal.equals_lower("ends") && StructInProgress.size() > 1 &&
+        getTok().is(AsmToken::EndOfStatement)) {
+      return parseDirectiveNestedEnds();
+    }
+
     // First, check the extension directive map to see if any extension has
     // registered itself to parse this directive.
     std::pair<MCAsmParserExtension *, DirectiveHandler> Handler =
         ExtensionDirectiveMap.lookup(IDVal.lower());
     if (Handler.first)
       return (*Handler.second)(Handler.first, IDVal, IDLoc);
 
     // Next, let the target-specific assembly parser try.
if (DirKind != DK_NO_DIRECTIVE) {
     case DK_QWORD:
     case DK_SQWORD:
     case DK_DQ:
       return parseDirectiveValue(IDVal, 8);
     case DK_REAL4:
       return parseDirectiveRealValue(IDVal, APFloat::IEEEsingle());
     case DK_REAL8:
       return parseDirectiveRealValue(IDVal, APFloat::IEEEdouble());
+    case DK_STRUCT:
+    case DK_UNION:
+      return parseDirectiveNestedStruct(IDVal, DirKind);
+    case DK_ENDS:
+      return parseDirectiveNestedEnds();
     case DK_ALIGN:
       return parseDirectiveAlign();
     case DK_ORG:
       return parseDirectiveOrg();
     case DK_EXTERN:
       eatToEndOfStatement(); // .extern is the default, ignore it.
       return false;
     case DK_PUBLIC:
case DK_ERRNZ:
       return parseDirectiveErrorIfe(IDLoc, false);
     case DK_ECHO:
       return parseDirectiveEcho();
     }
 
     return Error(IDLoc, "unknown directive");
   }
 
+  // We also check if this is allocating memory with user-defined type.
+  auto IDIt = Structs.find(IDVal.lower());
+  if (IDIt != Structs.end())
+    return parseDirectiveStructValue(/*Structure=*/IDIt->getValue(), IDVal,
+                                     IDLoc);
+
   // Non-conditional Microsoft directives sometimes follow their first argument.
   const AsmToken nextTok = getTok();
   const StringRef nextVal = nextTok.getString();
   const SMLoc nextLoc = nextTok.getLoc();
 
   // There are several entities interested in parsing infix directives:
   //
   // 1. Asm parser extensions. For example, platform-specific parsers
   //    (like the ELF parser) register themselves as extensions.
   // 2. The generic directive parser implemented by this class. These are
   //    all the directives that behave in a target and platform independent
   //    manner, or at least have a default behavior that's shared between
   //    all targets and platforms.
 
   getTargetParser().flushPendingInstructions(getStreamer());
 
+  // Special-case handling of structure-end directives at higher priority, since
+  // ENDS is overloaded as a segment-end directive.
+  if (nextVal.equals_lower("ends") && StructInProgress.size() == 1 &&
+      IDVal.equals_lower(StructInProgress.back().Name)) {
+    Lex();
+    return parseDirectiveEnds(IDVal, IDLoc);
+  }
+
   // First, check the extension directive map to see if any extension has
   // registered itself to parse this directive.
   std::pair<MCAsmParserExtension *, DirectiveHandler> Handler =
       ExtensionDirectiveMap.lookup(nextVal.lower());
   if (Handler.first) {
     Lex();
     Lexer.UnLex(ID);
     return (*Handler.second)(Handler.first, nextVal, nextLoc);
   }
 
-  // Finally, if no one else is interested in this directive, it must be
+  // If no one else is interested in this directive, it must be
   // generic and familiar to this class.
   DirKindIt = DirectiveKindMap.find(nextVal.lower());
   DirKind = (DirKindIt == DirectiveKindMap.end())
                 ? DK_NO_DIRECTIVE
                 : DirKindIt->getValue();
   switch (DirKind) {
   default:
     break;
bool MasmParser::parseStatement(ParseStatementInfo &Info,
   case DK_REAL4:
     Lex();
     return parseDirectiveNamedRealValue(nextVal, APFloat::IEEEsingle(), IDVal,
                                         IDLoc);
   case DK_REAL8:
     Lex();
     return parseDirectiveNamedRealValue(nextVal, APFloat::IEEEdouble(), IDVal,
                                         IDLoc);
+  case DK_STRUCT:
+  case DK_UNION:
+    Lex();
+    return parseDirectiveStruct(nextVal, DirKind, IDVal, IDLoc);
+  case DK_ENDS:
+    Lex();
+    return parseDirectiveEnds(IDVal, IDLoc);
+  }
+
+  // Finally, we check if this is allocating a variable with user-defined type.
+  auto NextIt = Structs.find(nextVal.lower());
+  if (NextIt != Structs.end()) {
+    Lex();
+    return parseDirectiveNamedStructValue(/*Structure=*/NextIt->getValue(),
+                                          nextVal, nextLoc, IDVal);
   }
 
   // __asm _emit or __asm __emit
   if (ParsingMSInlineAsm && (IDVal == "_emit" || IDVal == "__emit" ||
                              IDVal == "_EMIT" || IDVal == "__EMIT"))
     return parseDirectiveMSEmit(IDLoc, Info, IDVal.size());
 
   // __asm align
auto parseOp = [&]() -> bool {
     return false;
   };
 
   if (parseMany(parseOp))
     return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
   return false;
 }
 
-bool MasmParser::parseScalarInstList(unsigned Size,
-                                     SmallVectorImpl<const MCExpr *> &Values) {
-  do {
-    if (getTok().is(AsmToken::String)) {
-      StringRef Value = getTok().getStringContents();
-      if (Size == 1) {
-        // Treat each character as an initializer.
-        for (const char CharVal : Value)
-          Values.push_back(MCConstantExpr::create(CharVal, getContext()));
-      } else {
-        // Treat the string as an initial value in big-endian representation.
-        if (Value.size() > Size)
-          return Error(getTok().getLoc(), "out of range literal value");
+bool MasmParser::emitIntValue(const MCExpr *Value, unsigned Size) {
+  // Special case constant expressions to match code
+  // generator.
+  if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value)) {
+    assert(Size <= 8 && "Invalid size");
+    int64_t IntValue = MCE->getValue();
+    if (!isUIntN(8 * Size, IntValue) && !isIntN(8 * Size, IntValue))
+      return Error(MCE->getLoc(), "out of range literal value");
+    getStreamer().emitIntValue(IntValue, Size);
+  } else {
+    const MCSymbolRefExpr *MSE = dyn_cast<MCSymbolRefExpr>(Value);
+    if (MSE && MSE->getSymbol().getName() == "?") {
+      // ? initializer; treat as 0.
+      getStreamer().emitIntValue(0, Size);
+    } else {
+      getStreamer().emitValue(Value, Size, Value->getLoc());
+    }
+  }
+  return false;
+}
+
+bool MasmParser::parseScalarInitializer(unsigned Size,
+                                        SmallVectorImpl<const MCExpr *> &Values,
+                                        unsigned StringPadLength) {
+
+      // Pad the string with spaces to the specified length
+      for (size_t i = Value.size(); i < StringPadLength; ++i)
+        Values.push_back(MCConstantExpr::create(' ', getContext()));
 
-        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))
-        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");
-        const int64_t Repetitions = MCE->getValue();
-        if (Repetitions < 0)
-          return Error(Value->getLoc(),
-                       "cannot repeat value a negative number of times");
+      Lex(); // eat 'dup'
 
-        SmallVector<const MCExpr *, 1> DuplicatedValues;
-        if (parseToken(AsmToken::LParen,
-                       "parentheses required for 'dup' contents") ||
-            parseScalarInstList(Size, DuplicatedValues) ||
-            parseToken(AsmToken::RParen, "unmatched parentheses"))
-          return true;
 
-        for (int i = 0; i < Repetitions; ++i)
-          Values.append(DuplicatedValues.begin(), DuplicatedValues.end());
-      } else {
-        Values.push_back(Value);
-      }
-    }
+  return false;
+}
 
-    // Continue if we see a comma. (Also, allow line continuation.)
-  } while (parseOptionalToken(AsmToken::Comma) &&
-           (getTok().isNot(AsmToken::EndOfStatement) ||
-            !parseToken(AsmToken::EndOfStatement)));
+bool MasmParser::parseScalarInstList(unsigned Size,
+                                     SmallVectorImpl<const MCExpr *> &Values,
+                                     const AsmToken::TokenKind EndToken) {
+  while (getTok().isNot(EndToken) &&
+         (EndToken != AsmToken::Greater ||
+          getTok().isNot(AsmToken::GreaterGreater))) {
+    parseScalarInitializer(Size, Values);
 
+    // If we see a comma, continue, and allow line continuation.
+    if (!parseOptionalToken(AsmToken::Comma))
+      break;
+    parseOptionalToken(AsmToken::EndOfStatement);
+  }
   return false;
 }
 
 /// parseDirectiveValue
 ///  ::= (byte | word | ... ) [ expression (, expression)* ]
 bool MasmParser::parseDirectiveValue(StringRef IDVal, unsigned Size) {
+  if (StructInProgress.empty()) {
+    // Initialize data value
     SmallVector<const MCExpr *, 1> Values;
     if (parseScalarInstList(Size, Values))
       return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
 
-  for (const MCExpr *Value : Values) {
-    // Special case constant expressions to match code generator.
-    if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value)) {
-      assert(Size <= 8 && "Invalid size");
-      int64_t IntValue = MCE->getValue();
-      if (!isUIntN(8 * Size, IntValue) && !isIntN(8 * Size, IntValue))
-        return Error(MCE->getLoc(), "out of range literal value");
-      getStreamer().emitIntValue(IntValue, Size);
-    } else {
-      const MCSymbolRefExpr *MSE = dyn_cast<MCSymbolRefExpr>(Value);
-      if (MSE && MSE->getSymbol().getName() == "?") {
-        // ? initializer; treat as 0.
-        getStreamer().emitIntValue(0, Size);
-      } else {
-        getStreamer().emitValue(Value, Size, Value->getLoc());
-      }
+    for (auto Value : Values) {
+      emitIntValue(Value, Size);
     }
+  } else {
+    // Declare a field in the current struct
+    StructInfo &Struct = StructInProgress.back();
+    FieldInfo &Field = Struct.addField("", FT_INTEGRAL);
+    IntFieldInfo &IntInfo = Field.Contents.IntInfo;
+
+    Field.Type = Size;
+
+    if (parseScalarInstList(Size, IntInfo.Values))
+      return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
+
+    Field.SizeOf = Field.Type * IntInfo.Values.size();
+    Field.LengthOf = IntInfo.Values.size();
+    if (Struct.IsUnion)
+      Struct.Size = std::max(Struct.Size, Field.SizeOf);
+    else
+      Struct.Size += Field.SizeOf;
   }
+
   return false;
 }
 
 /// parseDirectiveNamedValue
 ///  ::= name (byte | word | ... ) [ expression (, expression)* ]
 bool MasmParser::parseDirectiveNamedValue(StringRef IDVal, unsigned Size,
                                           StringRef Name, SMLoc NameLoc) {
+  if (StructInProgress.empty()) {
+    // Initialize named data value
     MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
     getStreamer().emitLabel(Sym);
     return parseDirectiveValue(IDVal, Size);
+  } else {
+    // Declare a field in the current struct
+    StructInfo &Struct = StructInProgress.back();
+    FieldInfo &Field = Struct.addField(Name, FT_INTEGRAL);
+    IntFieldInfo &IntInfo = Field.Contents.IntInfo;
+
+    Field.Type = Size;
+
+    if (parseScalarInstList(Size, IntInfo.Values))
+      return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
+
+    Field.SizeOf = Field.Type * IntInfo.Values.size();
+    Field.LengthOf = IntInfo.Values.size();
+    if (Struct.IsUnion)
+      Struct.Size = std::max(Struct.Size, Field.SizeOf);
+    else
+      Struct.Size += Field.SizeOf;
+
+    return false;
+  }
 }
 
 static bool parseHexOcta(MasmParser &Asm, uint64_t &hi, uint64_t &lo) {
   if (Asm.getTok().isNot(AsmToken::Integer) &&
       Asm.getTok().isNot(AsmToken::BigNum))
     return Asm.TokError("unknown token in expression");
   SMLoc ExprLoc = Asm.getTok().getLoc();
   APInt IntValue = Asm.getTok().getAPIntVal();
bool MasmParser::parseRealValue(const fltSemantics &Semantics, APInt &Res) {
   // Convert to an APFloat.
   APFloat Value(Semantics);
   StringRef IDVal = getTok().getString();
   if (getLexer().is(AsmToken::Identifier)) {
     if (!IDVal.compare_lower("infinity") || !IDVal.compare_lower("inf"))
       Value = APFloat::getInf(Semantics);
     else if (!IDVal.compare_lower("nan"))
       Value = APFloat::getNaN(Semantics, false, ~0);
+    else if (!IDVal.compare_lower("?"))
+      Value = APFloat::getZero(Semantics);
     else
       return TokError("invalid floating point literal");
   } else if (errorToBool(
                  Value.convertFromString(IDVal, APFloat::rmNearestTiesToEven)
                      .takeError()))
     return TokError("invalid floating point literal");
   if (IsNeg)
     Value.changeSign();
 
   // Consume the numeric token.
   Lex();
 
   Res = Value.bitcastToAPInt();
 
   return false;
 }
 
 bool MasmParser::parseRealInstList(const fltSemantics &Semantics,
-                                   SmallVectorImpl<APInt> &ValuesAsInt) {
-  do {
+                                   SmallVectorImpl<APInt> &ValuesAsInt,
+                                   const AsmToken::TokenKind EndToken) {
+  while (getTok().isNot(EndToken) ||
+         (EndToken == AsmToken::Greater &&
+          getTok().isNot(AsmToken::GreaterGreater))) {
     const AsmToken NextTok = Lexer.peekTok();
     if (NextTok.is(AsmToken::Identifier) &&
         NextTok.getString().equals_lower("dup")) {
       const MCExpr *Value;
       if (parseExpression(Value) || parseToken(AsmToken::Identifier))
         return true;
       const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value);
       if (!MCE)
if (NextTok.is(AsmToken::Identifier) &&
       for (int i = 0; i < Repetitions; ++i)
         ValuesAsInt.append(DuplicatedValues.begin(), DuplicatedValues.end());
     } else {
       APInt AsInt;
       if (parseRealValue(Semantics, AsInt))
         return true;
       ValuesAsInt.push_back(AsInt);
     }
+
     // Continue if we see a comma. (Also, allow line continuation.)
-  } while (parseOptionalToken(AsmToken::Comma) &&
-           (getTok().isNot(AsmToken::EndOfStatement) ||
-            !parseToken(AsmToken::EndOfStatement)));
+    if (!parseOptionalToken(AsmToken::Comma))
+      break;
+    parseOptionalToken(AsmToken::EndOfStatement);
+  }
 
   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
     SmallVector<APInt, 1> ValuesAsInt;
     if (parseRealInstList(Semantics, ValuesAsInt))
       return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
 
     for (const APInt &AsInt : ValuesAsInt) {
       getStreamer().emitIntValue(AsInt.getLimitedValue(),
                                  AsInt.getBitWidth() / 8);
     }
+  } else {
+    // Declare a field in the current struct
+    StructInfo &Struct = StructInProgress.back();
+    FieldInfo &Field = Struct.addField("", FT_REAL);
+    RealFieldInfo &RealInfo = Field.Contents.RealInfo;
+
+    Field.SizeOf = 0;
+
+    if (checkForValidSection() ||
+        parseRealInstList(Semantics, RealInfo.AsIntValues))
+      return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
+
+    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;
 }
 
 /// parseDirectiveNamedRealValue
 ///  ::= name (real4 | real8) [ expression (, expression)* ]
 bool MasmParser::parseDirectiveNamedRealValue(StringRef IDVal,
                                               const fltSemantics &Semantics,
                                               StringRef Name, SMLoc NameLoc) {
+  if (StructInProgress.empty()) {
+    // Initialize named data value
     MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
     getStreamer().emitLabel(Sym);
     return parseDirectiveRealValue(IDVal, Semantics);
+  } else {
+    // Declare a field in the current struct
+    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))
+      return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
+
+    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;
+  }
+}
+
+bool MasmParser::parseFieldInitializer(const FieldInfo &Field,
+                                       const IntFieldInfo &Contents,
+                                       FieldInitializer &Initializer) {
+  const AsmToken &Tok = getTok();
+  SMLoc Loc = Tok.getLoc();
+
+  SmallVector<const MCExpr *, 1> Values;
+  if (Tok.is(AsmToken::LCurly) || Tok.is(AsmToken::Less) ||
+      Tok.is(AsmToken::LessLess) || Tok.is(AsmToken::LessGreater)) {
+    if (Field.LengthOf == 1 && Field.Type > 1)
+      return Error(Loc, "Cannot initialize scalar field with array value");
+
+    Optional<AsmToken::TokenKind> EndToken;
+    if (parseOptionalToken(AsmToken::LCurly)) {
+      EndToken = AsmToken::RCurly;
+    } else if (parseOptionalToken(AsmToken::Less)) {
+      EndToken = AsmToken::Greater;
+      AngleBracketDepth++;
+    } else if (parseOptionalToken(AsmToken::LessLess)) {
+      // Split << into two tokens, and parse the first.
+      EndToken = AsmToken::Greater;
+      AngleBracketDepth++;
+      Lexer.UnLex(AsmToken(AsmToken::Less, Tok.getString().substr(1)));
+    } else {
+      // Empty angle-bracket initializer
+      if (parseToken(AsmToken::LessGreater))
+        return true;
+    }
+
+    if (EndToken.hasValue()) {
+      if (parseScalarInstList(Field.Type, Values, EndToken.getValue()))
+        return true;
+
+      if (EndToken.getValue() == AsmToken::Greater &&
+          getTok().is(AsmToken::GreaterGreater)) {
+        // Split >> into two tokens, and parse the first
+        AsmToken GGTok = getTok();
+        if (parseToken(AsmToken::GreaterGreater))
+          return true;
+        Lexer.UnLex(AsmToken(AsmToken::Greater, GGTok.getString().substr(1)));
+      } else if (parseToken(EndToken.getValue())) {
+        return true;
+      }
+
+      if (EndToken.getValue() == AsmToken::Greater)
+        AngleBracketDepth--;
+    }
+  } else if (Field.LengthOf > 1 && Field.Type > 1) {
+    return Error(Loc, "Cannot initialize array field with scalar value");
+  } else if (parseScalarInitializer(Field.Type, Values,
+                                    /*StringPadLength=*/Field.LengthOf)) {
+    return true;
+  }
+
+  if (Values.size() > Field.LengthOf)
+    return Error(Loc, "Initializer too long for field");
+  // Default-initialize all remaining values
+  Values.append(Contents.Values.begin() + Values.size(), Contents.Values.end());
+
+  Initializer = FieldInitializer(FT_INTEGRAL, std::move(Values));
+  return false;
+}
+
+bool MasmParser::parseFieldInitializer(const FieldInfo &Field,
+                                       const RealFieldInfo &Contents,
+                                       FieldInitializer &Initializer) {
+  const fltSemantics &Semantics =
+      (Field.Type == 4) ? APFloat::IEEEsingle() : APFloat::IEEEdouble();
+
+  const AsmToken &Tok = getTok();
+  SMLoc Loc = Tok.getLoc();
+
+  Optional<AsmToken::TokenKind> EndToken;
+  if (Tok.is(AsmToken::LCurly) || Tok.is(AsmToken::Less) ||
+      Tok.is(AsmToken::LessLess) || Tok.is(AsmToken::LessGreater)) {
+    if (Field.LengthOf == 1)
+      return Error(Loc, "Cannot initialize scalar field with array value");
+
+    Optional<AsmToken::TokenKind> EndToken;
+    if (parseOptionalToken(AsmToken::LCurly)) {
+      EndToken = AsmToken::RCurly;
+    } else if (parseOptionalToken(AsmToken::Less)) {
+      EndToken = AsmToken::Greater;
+      AngleBracketDepth++;
+    } else if (parseOptionalToken(AsmToken::LessLess)) {
+      // Split << into two tokens, and parse the first.
+      EndToken = AsmToken::Greater;
+      AngleBracketDepth++;
+      Lexer.UnLex(AsmToken(AsmToken::Less, Tok.getString().substr(1)));
+    } else {
+      // Empty angle-bracket initializer
+      if (parseToken(AsmToken::LessGreater))
+        return true;
+    }
+  } else if (Field.LengthOf > 1) {
+    return Error(Loc, "Cannot initialize array field with scalar value");
+  }
+
+  SmallVector<APInt, 1> AsIntValues;
+  if (EndToken.hasValue()) {
+    if (parseRealInstList(Semantics, AsIntValues, EndToken.getValue()))
+      return true;
+
+    if (EndToken.getValue() == AsmToken::Greater &&
+        getTok().is(AsmToken::GreaterGreater)) {
+      // Split >> into two tokens, and parse the first
+      AsmToken GGTok = getTok();
+      if (parseToken(AsmToken::GreaterGreater))
+        return true;
+      Lexer.UnLex(AsmToken(AsmToken::Greater, GGTok.getString().substr(1)));
+    } else if (parseToken(EndToken.getValue())) {
+      return true;
+    }
+
+    if (EndToken.getValue() == AsmToken::Greater)
+      AngleBracketDepth--;
+  } else {
+    APInt AsInt;
+    if (parseRealValue(Semantics, AsInt))
+      return true;
+    AsIntValues.push_back(std::move(AsInt));
+  }
+  // Default-initialize all remaining values
+  AsIntValues.append(Contents.AsIntValues.begin() + AsIntValues.size(),
+                     Contents.AsIntValues.end());
+
+  Initializer = FieldInitializer(FT_REAL, std::move(AsIntValues));
+  return false;
+}
+
+bool MasmParser::parseFieldInitializer(const FieldInfo &Field,
+                                       const StructFieldInfo &Contents,
+                                       FieldInitializer &Initializer) {
+  const AsmToken &Tok = getTok();
+
+  std::vector<StructInitializer> Initializers;
+  if (Field.LengthOf > 1) {
+    Optional<AsmToken::TokenKind> EndToken;
+    if (parseOptionalToken(AsmToken::LCurly)) {
+      EndToken = AsmToken::RCurly;
+    } else if (parseOptionalToken(AsmToken::Less)) {
+      EndToken = AsmToken::Greater;
+      AngleBracketDepth++;
+    } else if (parseOptionalToken(AsmToken::LessLess)) {
+      // Split << into two tokens, and parse the first.
+      EndToken = AsmToken::Greater;
+      AngleBracketDepth++;
+      Lexer.UnLex(AsmToken(AsmToken::Less, Tok.getString().substr(1)));
+    } else {
+      // Empty angle-bracket initializer
+      if (parseToken(AsmToken::LessGreater))
+        return true;
+    }
+
+    if (EndToken.hasValue()) {
+      if (parseStructInstList(Contents.Structure, Initializers,
+                              EndToken.getValue()))
+        return true;
+
+      if (EndToken.getValue() == AsmToken::Greater &&
+          getTok().is(AsmToken::GreaterGreater)) {
+        // Split >> into two tokens, and parse the first
+        AsmToken GGTok = getTok();
+        if (parseToken(AsmToken::GreaterGreater))
+          return true;
+        Lexer.UnLex(AsmToken(AsmToken::Greater, GGTok.getString().substr(1)));
+      } else if (parseToken(EndToken.getValue())) {
+        return true;
+      }
+
+      if (EndToken.getValue() == AsmToken::Greater)
+        AngleBracketDepth--;
+    }
+  } else {
+    Initializers.emplace_back();
+    if (parseStructInitializer(Contents.Structure, Initializers.back()))
+      return true;
+  }
+
+  // Default-initialize all remaining values
+  Initializers.insert(Initializers.end(),
+                      Contents.Initializers.begin() + Initializers.size(),
+                      Contents.Initializers.end());
+
+  Initializer =
+      FieldInitializer(FT_STRUCT, std::move(Initializers), Contents.Structure);
+  return false;
+}
+
+bool MasmParser::parseFieldInitializer(const FieldInfo &Field,
+                                       FieldInitializer &Initializer) {
+  switch (Field.Contents.FT) {
+  case FT_INTEGRAL:
+    return parseFieldInitializer(Field, Field.Contents.IntInfo, Initializer);
+  case FT_REAL:
+    return parseFieldInitializer(Field, Field.Contents.RealInfo, Initializer);
+  case FT_STRUCT:
+    return parseFieldInitializer(Field, Field.Contents.StructInfo, Initializer);
+  }
+}
+
+bool MasmParser::parseStructInitializer(const StructInfo &Structure,
+                                        StructInitializer &Initializer) {
+  const AsmToken FirstToken = getTok();
+
+  Optional<AsmToken::TokenKind> EndToken;
+  if (parseOptionalToken(AsmToken::LCurly)) {
+    EndToken = AsmToken::RCurly;
+  } else if (parseOptionalToken(AsmToken::Less)) {
+    EndToken = AsmToken::Greater;
+    AngleBracketDepth++;
+  } else if (parseOptionalToken(AsmToken::LessLess)) {
+    // Split << into two tokens, and parse the first.
+    EndToken = AsmToken::Greater;
+    AngleBracketDepth++;
+    Lexer.UnLex(AsmToken(AsmToken::Less, FirstToken.getString().substr(1)));
+  } else {
+    if (FirstToken.is(AsmToken::Identifier) && FirstToken.getString() == "?") {
+      // ? initializer; treat as empty
+      parseToken(AsmToken::Identifier);
+    } else {
+      // Empty angle-bracket initializer
+      if (parseToken(AsmToken::LessGreater))
+        return true;
+    }
+  }
+
+  auto &FieldInitializers = Initializer.FieldInitializers;
+  size_t FieldIndex = 0;
+  if (EndToken.hasValue()) {
+    // Initialize all fields with given initializers
+    while (getTok().isNot(EndToken.getValue())) {
+      const FieldInfo &Field = Structure.Fields[FieldIndex++];
+      if (parseOptionalToken(AsmToken::Comma)) {
+        FieldInitializers.push_back(Field.Contents);
+        continue;
+      } else {
+        FieldInitializers.emplace_back(Field.Contents.FT);
+        if (parseFieldInitializer(Field, FieldInitializers.back()))
+          return true;
+      }
+
+      if (!parseOptionalToken(AsmToken::Comma))
+        break;
+      parseOptionalToken(AsmToken::EndOfStatement);
+    }
+  }
+  // Default-initialize all remaining fields
+  for (auto It = Structure.Fields.begin() + FieldIndex;
+       It != Structure.Fields.end(); ++It) {
+    const FieldInfo &Field = *It;
+    FieldInitializers.push_back(Field.Contents);
+  }
+
+  if (EndToken.hasValue()) {
+    if (EndToken.getValue() == AsmToken::Greater &&
+        getTok().is(AsmToken::GreaterGreater)) {
+      // Split >> into two tokens, and parse the first
+      AsmToken GGTok = getTok();
+      if (parseToken(AsmToken::GreaterGreater))
+        return true;
+      Lexer.UnLex(AsmToken(AsmToken::Greater, GGTok.getString().substr(1)));
+    } else if (parseToken(EndToken.getValue())) {
+      return true;
+    }
+
+    if (EndToken.getValue() == AsmToken::Greater)
+      AngleBracketDepth--;
+  }
+
+  return false;
+}
+
+bool MasmParser::parseStructInstList(
+    const StructInfo &Structure, std::vector<StructInitializer> &Initializers,
+    const AsmToken::TokenKind EndToken) {
+  while (getTok().isNot(EndToken) ||
+         (EndToken == AsmToken::Greater &&
+          getTok().isNot(AsmToken::GreaterGreater))) {
+    const AsmToken NextTok = Lexer.peekTok();
+    if (NextTok.is(AsmToken::Identifier) &&
+        NextTok.getString().equals_lower("dup")) {
+      const MCExpr *Value;
+      if (parseExpression(Value) || parseToken(AsmToken::Identifier))
+        return true;
+      const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value);
+      if (!MCE)
+        return Error(Value->getLoc(),
+                     "cannot repeat value a non-constant number of times");
+      const int64_t Repetitions = MCE->getValue();
+      if (Repetitions < 0)
+        return Error(Value->getLoc(),
+                     "cannot repeat value a negative number of times");
+
+      std::vector<StructInitializer> DuplicatedValues;
+      if (parseToken(AsmToken::LParen,
+                     "parentheses required for 'dup' contents") ||
+          parseStructInstList(Structure, DuplicatedValues) ||
+          parseToken(AsmToken::RParen, "unmatched parentheses"))
+        return true;
+
+      for (int i = 0; i < Repetitions; ++i)
+        Initializers.insert(Initializers.end(), DuplicatedValues.begin(),
+                            DuplicatedValues.end());
+    } else {
+      Initializers.emplace_back();
+      if (parseStructInitializer(Structure, Initializers.back()))
+        return true;
+    }
+
+    // Continue if we see a comma. (Also, allow line continuation.)
+    if (!parseOptionalToken(AsmToken::Comma))
+      break;
+    parseOptionalToken(AsmToken::EndOfStatement);
+  }
+
+  return false;
+}
+
+bool MasmParser::emitFieldValue(const FieldInfo &Field,
+                                const IntFieldInfo &Contents) {
+  // Default-initialize all values
+  for (auto Value : Contents.Values) {
+    if (emitIntValue(Value, Field.Type))
+      return true;
+  }
+  return false;
+}
+
+bool MasmParser::emitFieldValue(const FieldInfo &Field,
+                                const RealFieldInfo &Contents) {
+  for (APInt AsInt : Contents.AsIntValues) {
+    getStreamer().emitIntValue(AsInt.getLimitedValue(),
+                               AsInt.getBitWidth() / 8);
+  }
+  return false;
+}
+
+bool MasmParser::emitFieldValue(const FieldInfo &Field,
+                                const StructFieldInfo &Contents) {
+  for (const auto &Initializer : Contents.Initializers) {
+    size_t Index = 0, Offset = 0;
+    for (const auto &SubField : Contents.Structure.Fields) {
+      getStreamer().emitZeros(SubField.Offset - Offset);
+      Offset = SubField.Offset + SubField.SizeOf;
+      emitFieldInitializer(SubField, Initializer.FieldInitializers[Index++]);
+    }
+  }
+  return false;
+}
+
+bool MasmParser::emitFieldValue(const FieldInfo &Field) {
+  switch (Field.Contents.FT) {
+  case FT_INTEGRAL:
+    return emitFieldValue(Field, Field.Contents.IntInfo);
+  case FT_REAL:
+    return emitFieldValue(Field, Field.Contents.RealInfo);
+  case FT_STRUCT:
+    return emitFieldValue(Field, Field.Contents.StructInfo);
+  }
+}
+
+bool MasmParser::emitStructValue(const StructInfo &Structure) {
+  size_t Offset = 0;
+  for (const auto &Field : Structure.Fields) {
+    getStreamer().emitZeros(Field.Offset - Offset);
+    Offset = Field.Offset + Field.SizeOf;
+    if (emitFieldValue(Field))
+      return true;
+  }
+  // Add final padding
+  if (Offset != Structure.Size)
+    getStreamer().emitZeros(Structure.Size - Offset);
+  return false;
+}
+
+bool MasmParser::emitFieldInitializer(const FieldInfo &Field,
+                                      const IntFieldInfo &Contents,
+                                      const IntFieldInfo &Initializer) {
+  for (const auto &Value : Initializer.Values) {
+    if (emitIntValue(Value, Field.Type))
+      return true;
+  }
+  // Default-initialize all remaining values
+  for (auto it = Contents.Values.begin() + Initializer.Values.size();
+       it != Contents.Values.end(); ++it) {
+    const auto &Value = *it;
+    if (emitIntValue(Value, Field.Type))
+      return true;
+  }
+  return false;
+}
+
+bool MasmParser::emitFieldInitializer(const FieldInfo &Field,
+                                      const RealFieldInfo &Contents,
+                                      const RealFieldInfo &Initializer) {
+  for (const auto &AsInt : Initializer.AsIntValues) {
+    getStreamer().emitIntValue(AsInt.getLimitedValue(),
+                               AsInt.getBitWidth() / 8);
+  }
+  // Default-initialize all remaining values
+  for (auto It = Contents.AsIntValues.begin() + Initializer.AsIntValues.size();
+       It != Contents.AsIntValues.end(); ++It) {
+    const auto &AsInt = *It;
+    getStreamer().emitIntValue(AsInt.getLimitedValue(),
+                               AsInt.getBitWidth() / 8);
+  }
+  return false;
+}
+
+bool MasmParser::emitFieldInitializer(const FieldInfo &Field,
+                                      const StructFieldInfo &Contents,
+                                      const StructFieldInfo &Initializer) {
+  for (const auto &Init : Initializer.Initializers) {
+    emitStructInitializer(Contents.Structure, Init);
+  }
+  // Default-initialize all remaining values
+  for (auto It =
+           Contents.Initializers.begin() + Initializer.Initializers.size();
+       It != Contents.Initializers.end(); ++It) {
+    const auto &Init = *It;
+    emitStructInitializer(Contents.Structure, Init);
+  }
+  return false;
+}
+
+bool MasmParser::emitFieldInitializer(const FieldInfo &Field,
+                                      const FieldInitializer &Initializer) {
+  switch (Field.Contents.FT) {
+  case FT_INTEGRAL:
+    return emitFieldInitializer(Field, Field.Contents.IntInfo,
+                                Initializer.IntInfo);
+  case FT_REAL:
+    return emitFieldInitializer(Field, Field.Contents.RealInfo,
+                                Initializer.RealInfo);
+  case FT_STRUCT:
+    return emitFieldInitializer(Field, Field.Contents.StructInfo,
+                                Initializer.StructInfo);
+  }
+}
+
+bool MasmParser::emitStructInitializer(const StructInfo &Structure,
+                                       const StructInitializer &Initializer) {
+  size_t Index = 0, Offset = 0;
+  for (const auto &Init : Initializer.FieldInitializers) {
+    const auto &Field = Structure.Fields[Index++];
+    getStreamer().emitZeros(Field.Offset - Offset);
+    Offset = Field.Offset + Field.SizeOf;
+    if (emitFieldInitializer(Field, Init))
+      return true;
+  }
+  // Default-initialize all remaining fields
+  for (auto It =
+           Structure.Fields.begin() + Initializer.FieldInitializers.size();
+       It != Structure.Fields.end(); ++It) {
+    const auto &Field = *It;
+    getStreamer().emitZeros(Field.Offset - Offset);
+    Offset = Field.Offset + Field.SizeOf;
+    if (emitFieldValue(Field))
+      return true;
+  }
+  // Add final padding
+  if (Offset != Structure.Size)
+    getStreamer().emitZeros(Structure.Size - Offset);
+  return false;
+}
+
+/// parseDirectiveStructValue
+///  ::= struct-id (<struct-initializer> | {struct-initializer})
+///                [, (<struct-initializer> | {struct-initializer})]*
+bool MasmParser::parseDirectiveStructValue(const StructInfo &Structure,
+                                           StringRef Directive, SMLoc DirLoc) {
+  if (StructInProgress.empty()) {
+    // Initialize named data value
+    std::vector<StructInitializer> Initializers;
+    if (parseStructInstList(Structure, Initializers))
+      return true;
+
+    for (const auto &Initializer : Initializers) {
+      if (emitStructInitializer(Structure, Initializer))
+        return true;
+    }
+  } else {
+    // Declare a field in the current struct
+    StructInfo &OwningStruct = StructInProgress.back();
+    FieldInfo &Field = OwningStruct.addField("", FT_STRUCT);
+    StructFieldInfo &StructInfo = Field.Contents.StructInfo;
+
+    StructInfo.Structure = Structure;
+    Field.Type = Structure.Size;
+
+    if (parseStructInstList(Structure, StructInfo.Initializers))
+      return addErrorSuffix(" in '" + Twine(Directive) + "' directive");
+
+    Field.LengthOf = StructInfo.Initializers.size();
+    Field.SizeOf = Field.Type * Field.LengthOf;
+    if (OwningStruct.IsUnion)
+      OwningStruct.Size = std::max(OwningStruct.Size, Field.SizeOf);
+    else
+      OwningStruct.Size += Field.SizeOf;
+  }
+
+  return false;
+}
+
+/// parseDirectiveNamedValue
+///  ::= name (byte | word | ... ) [ expression (, expression)* ]
+bool MasmParser::parseDirectiveNamedStructValue(const StructInfo &Structure,
+                                                StringRef Directive,
+                                                SMLoc DirLoc, StringRef Name) {
+  if (StructInProgress.empty()) {
+    // Initialize named data value
+    MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
+    getStreamer().emitLabel(Sym);
+    KnownType[Name] = &Structure;
+    return parseDirectiveStructValue(Structure, Directive, DirLoc);
+  } else {
+    // Declare a field in the current struct
+    StructInfo &OwningStruct = StructInProgress.back();
+    FieldInfo &Field = OwningStruct.addField(Name, FT_STRUCT);
+    StructFieldInfo &StructInfo = Field.Contents.StructInfo;
+
+    StructInfo.Structure = Structure;
+    Field.Type = Structure.Size;
+
+    if (parseStructInstList(Structure, StructInfo.Initializers))
+      return addErrorSuffix(" in '" + Twine(Directive) + "' directive");
+
+    Field.LengthOf = StructInfo.Initializers.size();
+    Field.SizeOf = Field.Type * Field.LengthOf;
+    if (OwningStruct.IsUnion)
+      OwningStruct.Size = std::max(OwningStruct.Size, Field.SizeOf);
+    else
+      OwningStruct.Size += Field.SizeOf;
+
+    return false;
+  }
+}
+
+/// parseDirectiveStruct
+///  ::= <name> (STRUC | STRUCT | UNION) [fieldAlign] [, NONUNIQUE]
+///      (dataDir | generalDir | offsetDir | nestedStruct)+
+///      <name> ENDS
+////// dataDir = data declaration
+////// offsetDir = EVEN, ORG, ALIGN
+bool MasmParser::parseDirectiveStruct(StringRef Directive,
+                                      DirectiveKind DirKind, StringRef Name,
+                                      SMLoc NameLoc) {
+  // We ignore NONUNIQUE; we do not support OPTION M510 or OPTION OLDSTRUCTS
+  // anyway, so all field accesses must be qualified.
+  AsmToken NextTok = getTok();
+  int64_t AlignmentValue = 1;
+  if (NextTok.isNot(AsmToken::Comma) &&
+      NextTok.isNot(AsmToken::EndOfStatement) &&
+      parseAbsoluteExpression(AlignmentValue)) {
+    return addErrorSuffix(" in alignment value for '" + Twine(Directive) +
+                          "' directive");
+  }
+  if (!isPowerOf2_64(AlignmentValue))
+    return Error(NextTok.getLoc(), "unsupported alignment value");
+
+  StringRef Qualifier;
+  if (parseOptionalToken(AsmToken::Comma) && parseIdentifier(Qualifier))
+    return addErrorSuffix(" in '" + Twine(Directive) + "' directive");
+  if (!Qualifier.empty() && !Qualifier.equals_lower("nonunique"))
+    return Error(NameLoc, "Unrecognized qualifier for '" + Twine(Directive) +
+                              "' directive; expected none or NONUNIQUE");
+
+  if (parseToken(AsmToken::EndOfStatement))
+    return addErrorSuffix(" in '" + Twine(Directive) + "' directive");
+
+  StructInProgress.emplace_back(Name, DirKind == DK_UNION, AlignmentValue);
+  return false;
+}
+
+/// parseDirectiveNestedStruct
+///  ::= (STRUC | STRUCT | UNION) [name]
+///      (dataDir | generalDir | offsetDir | nestedStruct)+
+///      ENDS
+bool MasmParser::parseDirectiveNestedStruct(StringRef Directive,
+                                            DirectiveKind DirKind) {
+  if (StructInProgress.empty())
+    return TokError("missing name in top-level '" + Twine(Directive) +
+                    "' directive");
+
+  StringRef Name;
+  if (getTok().is(AsmToken::Identifier)) {
+    Name = getTok().getIdentifier();
+    parseToken(AsmToken::Identifier);
+  }
+  if (parseToken(AsmToken::EndOfStatement))
+    return addErrorSuffix(" in '" + Twine(Directive) + "' directive");
+
+  StructInProgress.emplace_back(Name, DirKind == DK_UNION,
+                                StructInProgress.back().Alignment);
+  return false;
+}
+
+bool MasmParser::parseDirectiveEnds(StringRef Name, SMLoc NameLoc) {
+  if (StructInProgress.empty())
+    return Error(NameLoc, "ENDS directive without matching STRUC/STRUCT/UNION");
+  if (StructInProgress.size() > 1)
+    return Error(NameLoc, "unexpected name in nested ENDS directive");
+  if (StructInProgress.back().Name.compare_lower(Name))
+    return Error(NameLoc, "mismatched name in ENDS directive");
+  StructInfo Structure = StructInProgress.pop_back_val();
+  if (Structure.Size % Structure.Alignment != 0) {
+    // Pad to make the structure's size divisible by its alignment
+    Structure.Size +=
+        Structure.Alignment - (Structure.Size % Structure.Alignment);
+  }
+  Structs[Name.lower()] = Structure;
+
+  if (parseToken(AsmToken::EndOfStatement))
+    return addErrorSuffix(" in ENDS directive");
+
+  return false;
+}
+
+bool MasmParser::parseDirectiveNestedEnds() {
+  if (StructInProgress.empty())
+    return TokError("ENDS directive without matching STRUC/STRUCT/UNION");
+  if (StructInProgress.size() == 1)
+    return TokError("missing name in top-level ENDS directive");
+
+  if (parseToken(AsmToken::EndOfStatement))
+    return addErrorSuffix(" in nested ENDS directive");
+
+  StructInfo Structure = StructInProgress.pop_back_val();
+  if (Structure.Size % Structure.Alignment != 0) {
+    // Pad to make the structure's size divisible by its alignment
+    Structure.Size +=
+        Structure.Alignment - (Structure.Size % Structure.Alignment);
+  }
+  StructInfo &ParentStruct = StructInProgress.back();
+
+  FieldInfo &Field = ParentStruct.addField(Structure.Name, FT_STRUCT);
+  StructFieldInfo &StructInfo = Field.Contents.StructInfo;
+  Field.Type = Structure.Size;
+  Field.LengthOf = 1;
+  Field.SizeOf = Structure.Size;
+
+  if (ParentStruct.IsUnion)
+    ParentStruct.Size = std::max(ParentStruct.Size, Field.SizeOf);
+  else
+    ParentStruct.Size += Field.SizeOf;
+
+  StructInfo.Structure = Structure;
+  StructInfo.Initializers.emplace_back();
+  auto &FieldInitializers = StructInfo.Initializers.back().FieldInitializers;
+  for (const auto &SubField : Structure.Fields) {
+    FieldInitializers.push_back(SubField.Contents);
+  }
+
+  return false;
 }
 
 /// parseDirectiveOrg
 ///  ::= .org expression [ , expression ]
 bool MasmParser::parseDirectiveOrg() {
   const MCExpr *Offset;
   SMLoc OffsetLoc = Lexer.getLoc();
   if (checkForValidSection() || parseExpression(Offset))
void MasmParser::initializeDirectiveKindMap() {
   DirectiveKindMap[".errnz"] = DK_ERRNZ;
   // 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;
+  DirectiveKindMap["struct"] = DK_STRUCT;
+  DirectiveKindMap["union"] = DK_UNION;
+  DirectiveKindMap["ends"] = DK_ENDS;
 }
 
 MCAsmMacro *MasmParser::parseMacroLikeBody(SMLoc DirectiveLoc) {
   AsmToken EndToken, StartToken = getTok();
 
   unsigned NestLevel = 0;
   while (true) {
     // Check whether we have reached the end of the file.
if (AsmRewritePrecedence[AsmRewriteA->Kind] >
     return -1;
 
   if (AsmRewritePrecedence[AsmRewriteA->Kind] <
       AsmRewritePrecedence[AsmRewriteB->Kind])
     return 1;
   llvm_unreachable("Unstable rewrite sort.");
 }
 
+bool MasmParser::LookupFieldOffset(StringRef Base, StringRef Member,
+                                   unsigned &Offset) {
+  if (Base.empty())
+    return true;
+
+  auto TypeIt = KnownType.find(Base);
+  if (TypeIt != KnownType.end())
+    return LookupFieldOffset(*TypeIt->second, Member, Offset);
+
+  auto StructIt = Structs.find(Base.lower());
+  if (StructIt != Structs.end())
+    return LookupFieldOffset(StructIt->second, Member, Offset);
+
+  return true;
+}
+
+bool MasmParser::LookupFieldOffset(const StructInfo &Structure,
+                                   StringRef Member, unsigned &Offset) {
+  std::pair<StringRef, StringRef> Split = Member.split('.');
+  const StringRef FieldName = Split.first, FieldMember = Split.second;
+
+  auto FieldIt = Structure.FieldsByName.find(FieldName.lower());
+  if (FieldIt == Structure.FieldsByName.end())
+    return true;
+
+  const FieldInfo &Field = Structure.Fields[FieldIt->second];
+  if (FieldMember.empty()) {
+    Offset = Field.Offset;
+    return false;
+  }
+
+  if (Field.Contents.FT != FT_STRUCT)
+    return true;
+  const StructFieldInfo &StructInfo = Field.Contents.StructInfo;
+
+  bool Result = LookupFieldOffset(StructInfo.Structure, FieldMember, Offset);
+  if (Result)
+    return true;
+
+  Offset += Field.Offset;
+  return false;
+}
+
 bool MasmParser::parseMSInlineAsm(
     void *AsmLoc, std::string &AsmString, unsigned &NumOutputs,
     unsigned &NumInputs, SmallVectorImpl<std::pair<void *, bool>> &OpDecls,
     SmallVectorImpl<std::string> &Constraints,
     SmallVectorImpl<std::string> &Clobbers, const MCInstrInfo *MII,
     const MCInstPrinter *IP, MCAsmParserSemaCallback &SI) {
   SmallVector<void *, 4> InputDecls;
   SmallVector<void *, 4> OutputDecls;

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

 //===-- X86AsmParser.cpp - Parse X86 assembly to MCInst instructions ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "MCTargetDesc/X86BaseInfo.h"
bool Error(SMLoc L, const Twine &Msg, SMRange Range = None,
     return Parser.Error(L, Msg, Range);
   }
 
   std::nullptr_t ErrorOperand(SMLoc Loc, StringRef Msg, SMRange R = SMRange()) {
     Error(Loc, Msg, R);
     return nullptr;
   }
 
+  bool MatchRegisterByName(unsigned &RegNo, StringRef RegName, SMLoc StartLoc,
+                           SMLoc EndLoc);
   bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc,
                      bool RestoreOnFailure);
 
   std::unique_ptr<X86Operand> DefaultMemSIOperand(SMLoc Loc);
   std::unique_ptr<X86Operand> DefaultMemDIOperand(SMLoc Loc);
   bool IsSIReg(unsigned Reg);
   unsigned GetSIDIForRegClass(unsigned RegClassID, unsigned Reg, bool IsSIReg);
   void
if (!Is64BitMode && BaseReg != 0 &&
       (BaseReg == X86::RIP || BaseReg == X86::EIP)) {
     ErrMsg = "IP-relative addressing requires 64-bit mode";
     return true;
   }
 
   return checkScale(Scale, ErrMsg);
 }
 
+bool X86AsmParser::MatchRegisterByName(unsigned &RegNo, StringRef RegName,
+                                       SMLoc StartLoc, SMLoc EndLoc) {
+  // If we encounter a %, ignore it. This code handles registers with and
+  // without the prefix, unprefixed registers can occur in cfi directives.
+  RegName.consume_front("%");
+
+  RegNo = MatchRegisterName(RegName);
+
+  // If the match failed, try the register name as lowercase.
+  if (RegNo == 0)
+    RegNo = MatchRegisterName(RegName.lower());
+
+  // The "flags" and "mxcsr" registers cannot be referenced directly.
+  // Treat it as an identifier instead.
+  if (isParsingMSInlineAsm() && isParsingIntelSyntax() &&
+      (RegNo == X86::EFLAGS || RegNo == X86::MXCSR))
+    RegNo = 0;
+
+  if (!is64BitMode()) {
+    // FIXME: This should be done using Requires<Not64BitMode> and
+    // Requires<In64BitMode> so "eiz" usage in 64-bit instructions can be also
+    // checked.
+    // FIXME: Check AH, CH, DH, BH cannot be used in an instruction requiring a
+    // REX prefix.
+    if (RegNo == X86::RIZ || RegNo == X86::RIP ||
+        X86MCRegisterClasses[X86::GR64RegClassID].contains(RegNo) ||
+        X86II::isX86_64NonExtLowByteReg(RegNo) ||
+        X86II::isX86_64ExtendedReg(RegNo)) {
+      return Error(StartLoc,
+                   "register %" + RegName + " is only available in 64-bit mode",
+                   SMRange(StartLoc, EndLoc));
+    }
+  }
+
+  // If this is "db[0-15]", match it as an alias
+  // for dr[0-15].
+  if (RegNo == 0 && RegName.startswith("db")) {
+    if (RegName.size() == 3) {
+      switch (RegName[2]) {
+      case '0':
+        RegNo = X86::DR0;
+        break;
+      case '1':
+        RegNo = X86::DR1;
+        break;
+      case '2':
+        RegNo = X86::DR2;
+        break;
+      case '3':
+        RegNo = X86::DR3;
+        break;
+      case '4':
+        RegNo = X86::DR4;
+        break;
+      case '5':
+        RegNo = X86::DR5;
+        break;
+      case '6':
+        RegNo = X86::DR6;
+        break;
+      case '7':
+        RegNo = X86::DR7;
+        break;
+      case '8':
+        RegNo = X86::DR8;
+        break;
+      case '9':
+        RegNo = X86::DR9;
+        break;
+      }
+    } else if (RegName.size() == 4 && RegName[2] == '1') {
+      switch (RegName[3]) {
+      case '0':
+        RegNo = X86::DR10;
+        break;
+      case '1':
+        RegNo = X86::DR11;
+        break;
+      case '2':
+        RegNo = X86::DR12;
+        break;
+      case '3':
+        RegNo = X86::DR13;
+        break;
+      case '4':
+        RegNo = X86::DR14;
+        break;
+      case '5':
+        RegNo = X86::DR15;
+        break;
+      }
+    }
+  }
+
+  if (RegNo == 0) {
+    if (isParsingIntelSyntax())
+      return true;
+    return Error(StartLoc, "invalid register name", SMRange(StartLoc, EndLoc));
+  }
+  return false;
+}
+
 bool X86AsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
                                  SMLoc &EndLoc, bool RestoreOnFailure) {
   MCAsmParser &Parser = getParser();
   MCAsmLexer &Lexer = getLexer();
   RegNo = 0;
 
   SmallVector<AsmToken, 5> Tokens;
   auto OnFailure = [RestoreOnFailure, &Lexer, &Tokens]() {
bool X86AsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
 
   if (Tok.isNot(AsmToken::Identifier)) {
     OnFailure();
     if (isParsingIntelSyntax()) return true;
     return Error(StartLoc, "invalid register name",
                  SMRange(StartLoc, EndLoc));
   }
 
-  RegNo = MatchRegisterName(Tok.getString());
-
-  // If the match failed, try the register name as lowercase.
-  if (RegNo == 0)
-    RegNo = MatchRegisterName(Tok.getString().lower());
-
-  // The "flags" and "mxcsr" registers cannot be referenced directly.
-  // Treat it as an identifier instead.
-  if (isParsingMSInlineAsm() && isParsingIntelSyntax() &&
-      (RegNo == X86::EFLAGS || RegNo == X86::MXCSR))
-    RegNo = 0;
-
-  if (!is64BitMode()) {
-    // FIXME: This should be done using Requires<Not64BitMode> and
-    // Requires<In64BitMode> so "eiz" usage in 64-bit instructions can be also
-    // checked.
-    // FIXME: Check AH, CH, DH, BH cannot be used in an instruction requiring a
-    // REX prefix.
-    if (RegNo == X86::RIZ || RegNo == X86::RIP ||
-        X86MCRegisterClasses[X86::GR64RegClassID].contains(RegNo) ||
-        X86II::isX86_64NonExtLowByteReg(RegNo) ||
-        X86II::isX86_64ExtendedReg(RegNo)) {
-      StringRef RegName = Tok.getString();
-      OnFailure();
-      if (!RestoreOnFailure) {
-        Parser.Lex(); // Eat register name.
-      }
-      return Error(StartLoc,
-                   "register %" + RegName + " is only available in 64-bit mode",
-                   SMRange(StartLoc, EndLoc));
-    }
-  }
+  MatchRegisterByName(RegNo, Tok.getString(), StartLoc, EndLoc);
 
   // Parse "%st" as "%st(0)" and "%st(1)", which is multiple tokens.
   if (RegNo == X86::ST0) {
     Tokens.push_back(Tok);
     Parser.Lex(); // Eat 'st'
 
     // Check to see if we have '(4)' after %st.
     if (Lexer.isNot(AsmToken::LParen))
if (RegNo == X86::ST0) {
 
     EndLoc = Parser.getTok().getEndLoc();
     Parser.Lex(); // Eat ')'
     return false;
   }
 
   EndLoc = Parser.getTok().getEndLoc();
 
-  // If this is "db[0-15]", match it as an alias
-  // for dr[0-15].
-  if (RegNo == 0 && Tok.getString().startswith("db")) {
-    if (Tok.getString().size() == 3) {
-      switch (Tok.getString()[2]) {
-      case '0': RegNo = X86::DR0; break;
-      case '1': RegNo = X86::DR1; break;
-      case '2': RegNo = X86::DR2; break;
-      case '3': RegNo = X86::DR3; break;
-      case '4': RegNo = X86::DR4; break;
-      case '5': RegNo = X86::DR5; break;
-      case '6': RegNo = X86::DR6; break;
-      case '7': RegNo = X86::DR7; break;
-      case '8': RegNo = X86::DR8; break;
-      case '9': RegNo = X86::DR9; break;
-      }
-    } else if (Tok.getString().size() == 4 && Tok.getString()[2] == '1') {
-      switch (Tok.getString()[3]) {
-      case '0': RegNo = X86::DR10; break;
-      case '1': RegNo = X86::DR11; break;
-      case '2': RegNo = X86::DR12; break;
-      case '3': RegNo = X86::DR13; break;
-      case '4': RegNo = X86::DR14; break;
-      case '5': RegNo = X86::DR15; break;
-      }
-    }
-
-    if (RegNo != 0) {
-      EndLoc = Parser.getTok().getEndLoc();
-      Parser.Lex(); // Eat it.
-      return false;
-    }
-  }
-
   if (RegNo == 0) {
     OnFailure();
     if (isParsingIntelSyntax()) return true;
     return Error(StartLoc, "invalid register name",
                  SMRange(StartLoc, EndLoc));
   }
 
   Parser.Lex(); // Eat identifier token.
case AsmToken::Real:
         return true;
       break;
     case AsmToken::At:
     case AsmToken::String:
     case AsmToken::Identifier: {
       SMLoc IdentLoc = Tok.getLoc();
       StringRef Identifier = Tok.getString();
       UpdateLocLex = false;
-      // Register
+      // Register, or (MASM only) <register>.<field>
       unsigned Reg;
-      if (Tok.is(AsmToken::Identifier) && !ParseRegister(Reg, IdentLoc, End)) {
+      if (Tok.is(AsmToken::Identifier)) {
+        if (!ParseRegister(Reg, IdentLoc, End, /*RestoreOnFailure=*/true)) {
           if (SM.onRegister(Reg, ErrMsg))
-          return Error(Tok.getLoc(), ErrMsg);
+            return Error(IdentLoc, ErrMsg);
           break;
         }
+        if (Parser.isParsingMasm()) {
+          const std::pair<StringRef, StringRef> RegField =
+              Tok.getString().split('.');
+          const StringRef RegName = RegField.first, Field = RegField.second;
+          SMLoc RegEndLoc =
+              SMLoc::getFromPointer(RegName.data() + RegName.size());
+          if (!Field.empty() &&
+              !MatchRegisterByName(Reg, RegName, IdentLoc, RegEndLoc)) {
+            if (SM.onRegister(Reg, ErrMsg))
+              return Error(IdentLoc, ErrMsg);
+
+            SMLoc FieldStartLoc = SMLoc::getFromPointer(Field.data());
+            const std::pair<StringRef, StringRef> BaseMember = Field.split('.');
+            const StringRef Base = BaseMember.first, Member = BaseMember.second;
+
+            unsigned Offset;
+            if (Parser.LookupFieldOffset(Base, Member, Offset))
+              return Error(FieldStartLoc, "unknown offset");
+            else if (SM.onPlus(ErrMsg))
+              return Error(getTok().getLoc(), ErrMsg);
+            else if (SM.onInteger(Offset, ErrMsg))
+              return Error(IdentLoc, ErrMsg);
+
+            End = consumeToken();
+            break;
+          }
+        }
+      }
       // Operator synonymous ("not", "or" etc.)
       bool ParseError = false;
       if (ParseIntelNamedOperator(Identifier, SM, ParseError, End)) {
         if (ParseError)
           return true;
         break;
       }
       // Symbol reference, when parsing assembly content
       InlineAsmIdentifierInfo Info;
       const MCExpr *Val;
-      if (!isParsingMSInlineAsm()) {
-        if (getParser().parsePrimaryExpr(Val, End)) {
-          return Error(Tok.getLoc(), "Unexpected identifier!");
-        } else if (SM.onIdentifierExpr(Val, Identifier, Info, false, ErrMsg)) {
-          return Error(IdentLoc, ErrMsg);
-        } else
+      if (isParsingMSInlineAsm() || Parser.isParsingMasm()) {
+        // MS Dot Operator expression
+        if (Identifier.count('.') && PrevTK == AsmToken::RBrac) {
+          if (ParseIntelDotOperator(SM, End))
+            return true;
           break;
         }
+      }
+      if (isParsingMSInlineAsm()) {
         // MS InlineAsm operators (TYPE/LENGTH/SIZE)
         if (unsigned OpKind = IdentifyIntelInlineAsmOperator(Identifier)) {
           if (int64_t Val = ParseIntelInlineAsmOperator(OpKind)) {
             if (SM.onInteger(Val, ErrMsg))
               return Error(IdentLoc, ErrMsg);
           } else
             return true;
           break;
         }
-      // MS Dot Operator expression
-      if (Identifier.count('.') && PrevTK == AsmToken::RBrac) {
-        if (ParseIntelDotOperator(SM, End))
-          return true;
-        break;
-      }
         // MS InlineAsm identifier
         // Call parseIdentifier() to combine @ with the identifier behind it.
         if (TK == AsmToken::At && Parser.parseIdentifier(Identifier))
           return Error(IdentLoc, "expected identifier");
         if (ParseIntelInlineAsmIdentifier(Val, Identifier, Info, false, End))
           return true;
         else if (SM.onIdentifierExpr(Val, Identifier, Info, true, ErrMsg))
           return Error(IdentLoc, ErrMsg);
         break;
       }
+      if (getParser().parsePrimaryExpr(Val, End)) {
+        return Error(Tok.getLoc(), "Unexpected identifier!");
+      } else if (SM.onIdentifierExpr(Val, Identifier, Info, false, ErrMsg)) {
+        return Error(IdentLoc, ErrMsg);
+      }
+      break;
+    }
     case AsmToken::Integer: {
       // Look for 'b' or 'f' following an Integer as a directional label
       SMLoc Loc = getTok().getLoc();
       int64_t IntVal = getTok().getIntVal();
       End = consumeToken();
       UpdateLocLex = false;
       if (getLexer().getKind() == AsmToken::Identifier) {
         StringRef IDVal = getTok().getString();
bool X86AsmParser::ParseIntelDotOperator(IntelExprStateMachine &SM, SMLoc &End) {
   if (DotDispStr.startswith("."))
     DotDispStr = DotDispStr.drop_front(1);
 
   // .Imm gets lexed as a real.
   if (Tok.is(AsmToken::Real)) {
     APInt DotDisp;
     DotDispStr.getAsInteger(10, DotDisp);
     Offset = DotDisp.getZExtValue();
-  } else if (isParsingMSInlineAsm() && Tok.is(AsmToken::Identifier)) {
-    std::pair<StringRef, StringRef> BaseMember = DotDispStr.split('.');
-    if (SemaCallback->LookupInlineAsmField(BaseMember.first, BaseMember.second,
-                                           Offset))
+  } else if ((isParsingMSInlineAsm() || getParser().isParsingMasm()) &&
+             Tok.is(AsmToken::Identifier)) {
+    const std::pair<StringRef, StringRef> BaseMember = DotDispStr.split('.');
+    const StringRef Base = BaseMember.first, Member = BaseMember.second;
+    if (getParser().LookupFieldOffset(SM.getSymName(), DotDispStr, Offset) &&
+        getParser().LookupFieldOffset(Base, Member, Offset) &&
+        (!SemaCallback ||
+         SemaCallback->LookupInlineAsmField(Base, Member, Offset)))
       return Error(Tok.getLoc(), "Unable to lookup field reference!");
   } else
     return Error(Tok.getLoc(), "Unexpected token type!");
 
   // Eat the DotExpression and update End
   End = SMLoc::getFromPointer(DotDispStr.data());
   const char *DotExprEndLoc = DotDispStr.data() + DotDispStr.size();
   while (Tok.getLoc().getPointer() < DotExprEndLoc)

llvm/test/tools/llvm-ml/struct.test

+# RUN: llvm-ml -filetype=asm %s | FileCheck %s
+
+.data
+BAZ STRUCT
+  a BYTE 1
+  b BYTE 2
+BAZ ENDS
+
+FOOBAR STRUCT 2
+  c BYTE 3 DUP (4)
+  d DWORD 5
+  e BAZ <>
+  STRUCT f
+    g BYTE 6
+    h BYTE 7
+  ENDS
+  h BYTE "abcde"
+FOOBAR ENDS
+
+t1 FOOBAR <>
+
+; CHECK: t1:
+;
+; BYTE 3 DUP (4), plus alignment padding
+; CHECK-NEXT: .byte 4
+; CHECK-NEXT: .byte 4
+; CHECK-NEXT: .byte 4
+; CHECK-NEXT: .zero 1
+;
+; DWORD 5
+; CHECK-NEXT: .long 5
+;
+; BAZ <>
+; CHECK-NEXT: .byte 1
+; CHECK-NEXT: .byte 2
+;
+; <BYTE 6, BYTE 7>, with internal alignment padding
+; CHECK-NEXT: .byte 6
+; CHECK-NEXT: .zero 1
+; CHECK-NEXT: .byte 7
+; CHECK-NEXT: .zero 1
+;
+; BYTE "abcde", plus alignment padding
+; CHECK-NEXT: .byte 97
+; CHECK-NEXT: .byte 98
+; CHECK-NEXT: .byte 99
+; CHECK-NEXT: .byte 100
+; CHECK-NEXT: .byte 101
+; CHECK-NEXT: .zero 1
+
+t2 FOOBAR <"gh",,<10,11>,<12>,"ijk">
+
+; CHECK: t2:
+;
+; BYTE "gh", padded with " ", plus alignment padding
+; CHECK-NEXT: .byte 103
+; CHECK-NEXT: .byte 104
+; CHECK-NEXT: .byte 32
+; CHECK-NEXT: .zero 1
+;
+; DWORD 5 (default-initialized when omitted)
+; CHECK-NEXT: .long 5
+;
+; BAZ <10, 11>
+; CHECK-NEXT: .byte 10
+; CHECK-NEXT: .byte 11
+;
+; <BYTE 6, BYTE 7>, with internal alignment padding
+; CHECK-NEXT: .byte 12
+; CHECK-NEXT: .zero 1
+; CHECK-NEXT: .byte 7
+; CHECK-NEXT: .zero 1
+;
+; BYTE "ijk", padded with " ", plus alignment padding
+; CHECK-NEXT: .byte 105
+; CHECK-NEXT: .byte 106
+; CHECK-NEXT: .byte 107
+; CHECK-NEXT: .byte 32
+; CHECK-NEXT: .byte 32
+; CHECK-NEXT: .zero 1
+
+.code
+
+t3:
+mov eax, t2.f.h
+mov eax, [t2].f.h
+mov eax, [t2.f.h]
+mov eax, t2.FOOBAR.f.h
+
+; CHECK: t3:
+; CHECK-NEXT: mov eax, dword ptr [rip + t2+12]
+; CHECK-NEXT: mov eax, dword ptr [rip + t2+12]
+; CHECK-NEXT: mov eax, dword ptr [rip + t2+12]
+; CHECK-NEXT: mov eax, dword ptr [rip + t2+12]
+
+t4:
+mov eax, j.FOOBAR.f.h
+mov eax, j.baz.b
+
+; CHECK: t4:
+; CHECK-NEXT: mov eax, dword ptr [rip + j+12]
+; CHECK-NEXT: mov eax, dword ptr [rip + j+1]
+
+END