1	//===- AsmParser.cpp - Parser for Assembly Files --------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8	//
9	// This class implements the parser for assembly files.
10	//
11	//===----------------------------------------------------------------------===//
12
13	#include "llvm/ADT/APFloat.h"
14	#include "llvm/ADT/APInt.h"
15	#include "llvm/ADT/ArrayRef.h"
16	#include "llvm/ADT/BitVector.h"
17	#include "llvm/ADT/STLExtras.h"
18	#include "llvm/ADT/SmallString.h"
19	#include "llvm/ADT/SmallVector.h"
20	#include "llvm/ADT/StringExtras.h"
21	#include "llvm/ADT/StringMap.h"
22	#include "llvm/ADT/StringRef.h"
23	#include "llvm/ADT/StringSwitch.h"
24	#include "llvm/ADT/Twine.h"
25	#include "llvm/BinaryFormat/Dwarf.h"
26	#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
27	#include "llvm/MC/MCAsmInfo.h"
28	#include "llvm/MC/MCCodeView.h"
29	#include "llvm/MC/MCContext.h"
30	#include "llvm/MC/MCDirectives.h"
31	#include "llvm/MC/MCDwarf.h"
32	#include "llvm/MC/MCExpr.h"
33	#include "llvm/MC/MCInstPrinter.h"
34	#include "llvm/MC/MCInstrDesc.h"
35	#include "llvm/MC/MCInstrInfo.h"
36	#include "llvm/MC/MCParser/AsmCond.h"
37	#include "llvm/MC/MCParser/AsmLexer.h"
38	#include "llvm/MC/MCParser/MCAsmLexer.h"
39	#include "llvm/MC/MCParser/MCAsmParser.h"
40	#include "llvm/MC/MCParser/MCAsmParserExtension.h"
41	#include "llvm/MC/MCParser/MCParsedAsmOperand.h"
42	#include "llvm/MC/MCParser/MCTargetAsmParser.h"
43	#include "llvm/MC/MCRegisterInfo.h"
44	#include "llvm/MC/MCSection.h"
45	#include "llvm/MC/MCStreamer.h"
46	#include "llvm/MC/MCSubtargetInfo.h"
47	#include "llvm/MC/MCSymbol.h"
48	#include "llvm/MC/MCTargetOptions.h"
49	#include "llvm/Support/Casting.h"
50	#include "llvm/Support/CommandLine.h"
51	#include "llvm/Support/ErrorHandling.h"
52	#include "llvm/Support/Format.h"
53	#include "llvm/Support/MD5.h"
54	#include "llvm/Support/MathExtras.h"
55	#include "llvm/Support/MemoryBuffer.h"
56	#include "llvm/Support/Path.h"
57	#include "llvm/Support/SMLoc.h"
58	#include "llvm/Support/SourceMgr.h"
59	#include "llvm/Support/raw_ostream.h"
60	#include <algorithm>
61	#include <cassert>
62	#include <climits>
63	#include <cstddef>
64	#include <cstdint>
65	#include <ctime>
66	#include <deque>
67	#include <memory>
68	#include <optional>
69	#include <sstream>
70	#include <string>
71	#include <tuple>
72	#include <utility>
73	#include <vector>
74
75	using namespace llvm;
76
77	namespace {
78
79	/// Helper types for tracking macro definitions.
80	typedef std::vector<AsmToken> MCAsmMacroArgument;
81	typedef std::vector<MCAsmMacroArgument> MCAsmMacroArguments;
82
83	/// Helper class for storing information about an active macro instantiation.
84	struct MacroInstantiation {
85	/// The location of the instantiation.
86	SMLoc InstantiationLoc;
87
88	/// The buffer where parsing should resume upon instantiation completion.
89	unsigned ExitBuffer;
90
91	/// The location where parsing should resume upon instantiation completion.
92	SMLoc ExitLoc;
93
94	/// The depth of TheCondStack at the start of the instantiation.
95	size_t CondStackDepth;
96	};
97
98	struct ParseStatementInfo {
99	/// The parsed operands from the last parsed statement.
100	SmallVector<std::unique_ptr<MCParsedAsmOperand>, 8> ParsedOperands;
101
102	/// The opcode from the last parsed instruction.
103	unsigned Opcode = ~0U;
104
105	/// Was there an error parsing the inline assembly?
106	bool ParseError = false;
107
108	/// The value associated with a macro exit.
109	std::optional<std::string> ExitValue;
110
111	SmallVectorImpl<AsmRewrite> *AsmRewrites = nullptr;
112
113	ParseStatementInfo() = delete;
114	ParseStatementInfo(SmallVectorImpl<AsmRewrite> *rewrites)
115	: AsmRewrites(rewrites) {}
116	};
117
118	enum FieldType {
119	FT_INTEGRAL, // Initializer: integer expression, stored as an MCExpr.
120	FT_REAL, // Initializer: real number, stored as an APInt.
121	FT_STRUCT // Initializer: struct initializer, stored recursively.
122	};
123
124	struct FieldInfo;
125	struct StructInfo {
126	StringRef Name;
127	bool IsUnion = false;
128	bool Initializable = true;
129	unsigned Alignment = 0;
130	unsigned AlignmentSize = 0;
131	unsigned NextOffset = 0;
132	unsigned Size = 0;
133	std::vector<FieldInfo> Fields;
134	StringMap<size_t> FieldsByName;
135
136	FieldInfo &addField(StringRef FieldName, FieldType FT,
137	unsigned FieldAlignmentSize);
138
139	StructInfo() = default;
140	StructInfo(StringRef StructName, bool Union, unsigned AlignmentValue);
141	};
142
143	// FIXME: This should probably use a class hierarchy, raw pointers between the
144	// objects, and dynamic type resolution instead of a union. On the other hand,
145	// ownership then becomes much more complicated; the obvious thing would be to
146	// use BumpPtrAllocator, but the lack of a destructor makes that messy.
147
148	struct StructInitializer;
149	struct IntFieldInfo {
150	SmallVector<const MCExpr *, 1> Values;
151
152	IntFieldInfo() = default;
153	IntFieldInfo(const SmallVector<const MCExpr *, 1> &V) { Values = V; }
154	IntFieldInfo(SmallVector<const MCExpr *, 1> &&V) { Values = std::move(V); }
155	};
156	struct RealFieldInfo {
157	SmallVector<APInt, 1> AsIntValues;
158
159	RealFieldInfo() = default;
160	RealFieldInfo(const SmallVector<APInt, 1> &V) { AsIntValues = V; }
161	RealFieldInfo(SmallVector<APInt, 1> &&V) { AsIntValues = std::move(V); }
162	};
163	struct StructFieldInfo {
164	std::vector<StructInitializer> Initializers;
165	StructInfo Structure;
166
167	StructFieldInfo() = default;
168	StructFieldInfo(std::vector<StructInitializer> V, StructInfo S);
169	};
170
171	class FieldInitializer {
172	public:
173	FieldType FT;
174	union {
175	IntFieldInfo IntInfo;
176	RealFieldInfo RealInfo;
177	StructFieldInfo StructInfo;
178	};
179
180	~FieldInitializer();
181	FieldInitializer(FieldType FT);
182
183	FieldInitializer(SmallVector<const MCExpr *, 1> &&Values);
184	FieldInitializer(SmallVector<APInt, 1> &&AsIntValues);
185	FieldInitializer(std::vector<StructInitializer> &&Initializers,
186	struct StructInfo Structure);
187
188	FieldInitializer(const FieldInitializer &Initializer);
189	FieldInitializer(FieldInitializer &&Initializer);
190
191	FieldInitializer &operator=(const FieldInitializer &Initializer);
192	FieldInitializer &operator=(FieldInitializer &&Initializer);
193	};
194
195	struct StructInitializer {
196	std::vector<FieldInitializer> FieldInitializers;
197	};
198
199	struct FieldInfo {
200	// Offset of the field within the containing STRUCT.
201	unsigned Offset = 0;
202
203	// Total size of the field (= LengthOf * Type).
204	unsigned SizeOf = 0;
205
206	// Number of elements in the field (1 if scalar, >1 if an array).
207	unsigned LengthOf = 0;
208
209	// Size of a single entry in this field, in bytes ("type" in MASM standards).
210	unsigned Type = 0;
211
212	FieldInitializer Contents;
213
214	FieldInfo(FieldType FT) : Contents(FT) {}
215	};
216
217	StructFieldInfo::StructFieldInfo(std::vector<StructInitializer> V,
218	StructInfo S) {
219	Initializers = std::move(V);
220	Structure = S;
221	}
222
223	StructInfo::StructInfo(StringRef StructName, bool Union,
224	unsigned AlignmentValue)
225	: Name(StructName), IsUnion(Union), Alignment(AlignmentValue) {}
226
227	FieldInfo &StructInfo::addField(StringRef FieldName, FieldType FT,
228	unsigned FieldAlignmentSize) {
229	if (!FieldName.empty())
230	FieldsByName[FieldName.lower()] = Fields.size();
231	Fields.emplace_back(args&: FT);
232	FieldInfo &Field = Fields.back();
233	Field.Offset =
234	llvm::alignTo(Value: NextOffset, Align: std::min(a: Alignment, b: FieldAlignmentSize));
235	if (!IsUnion) {
236	NextOffset = std::max(a: NextOffset, b: Field.Offset);
237	}
238	AlignmentSize = std::max(a: AlignmentSize, b: FieldAlignmentSize);
239	return Field;
240	}
241
242	FieldInitializer::~FieldInitializer() {
243	switch (FT) {
244	case FT_INTEGRAL:
245	IntInfo.~IntFieldInfo();
246	break;
247	case FT_REAL:
248	RealInfo.~RealFieldInfo();
249	break;
250	case FT_STRUCT:
251	StructInfo.~StructFieldInfo();
252	break;
253	}
254	}
255
256	FieldInitializer::FieldInitializer(FieldType FT) : FT(FT) {
257	switch (FT) {
258	case FT_INTEGRAL:
259	new (&IntInfo) IntFieldInfo();
260	break;
261	case FT_REAL:
262	new (&RealInfo) RealFieldInfo();
263	break;
264	case FT_STRUCT:
265	new (&StructInfo) StructFieldInfo();
266	break;
267	}
268	}
269
270	FieldInitializer::FieldInitializer(SmallVector<const MCExpr *, 1> &&Values)
271	: FT(FT_INTEGRAL) {
272	new (&IntInfo) IntFieldInfo(std::move(Values));
273	}
274
275	FieldInitializer::FieldInitializer(SmallVector<APInt, 1> &&AsIntValues)
276	: FT(FT_REAL) {
277	new (&RealInfo) RealFieldInfo(std::move(AsIntValues));
278	}
279
280	FieldInitializer::FieldInitializer(
281	std::vector<StructInitializer> &&Initializers, struct StructInfo Structure)
282	: FT(FT_STRUCT) {
283	new (&StructInfo) StructFieldInfo(std::move(Initializers), Structure);
284	}
285
286	FieldInitializer::FieldInitializer(const FieldInitializer &Initializer)
287	: FT(Initializer.FT) {
288	switch (FT) {
289	case FT_INTEGRAL:
290	new (&IntInfo) IntFieldInfo(Initializer.IntInfo);
291	break;
292	case FT_REAL:
293	new (&RealInfo) RealFieldInfo(Initializer.RealInfo);
294	break;
295	case FT_STRUCT:
296	new (&StructInfo) StructFieldInfo(Initializer.StructInfo);
297	break;
298	}
299	}
300
301	FieldInitializer::FieldInitializer(FieldInitializer &&Initializer)
302	: FT(Initializer.FT) {
303	switch (FT) {
304	case FT_INTEGRAL:
305	new (&IntInfo) IntFieldInfo(Initializer.IntInfo);
306	break;
307	case FT_REAL:
308	new (&RealInfo) RealFieldInfo(Initializer.RealInfo);
309	break;
310	case FT_STRUCT:
311	new (&StructInfo) StructFieldInfo(Initializer.StructInfo);
312	break;
313	}
314	}
315
316	FieldInitializer &
317	FieldInitializer::operator=(const FieldInitializer &Initializer) {
318	if (FT != Initializer.FT) {
319	switch (FT) {
320	case FT_INTEGRAL:
321	IntInfo.~IntFieldInfo();
322	break;
323	case FT_REAL:
324	RealInfo.~RealFieldInfo();
325	break;
326	case FT_STRUCT:
327	StructInfo.~StructFieldInfo();
328	break;
329	}
330	}
331	FT = Initializer.FT;
332	switch (FT) {
333	case FT_INTEGRAL:
334	IntInfo = Initializer.IntInfo;
335	break;
336	case FT_REAL:
337	RealInfo = Initializer.RealInfo;
338	break;
339	case FT_STRUCT:
340	StructInfo = Initializer.StructInfo;
341	break;
342	}
343	return *this;
344	}
345
346	FieldInitializer &FieldInitializer::operator=(FieldInitializer &&Initializer) {
347	if (FT != Initializer.FT) {
348	switch (FT) {
349	case FT_INTEGRAL:
350	IntInfo.~IntFieldInfo();
351	break;
352	case FT_REAL:
353	RealInfo.~RealFieldInfo();
354	break;
355	case FT_STRUCT:
356	StructInfo.~StructFieldInfo();
357	break;
358	}
359	}
360	FT = Initializer.FT;
361	switch (FT) {
362	case FT_INTEGRAL:
363	IntInfo = Initializer.IntInfo;
364	break;
365	case FT_REAL:
366	RealInfo = Initializer.RealInfo;
367	break;
368	case FT_STRUCT:
369	StructInfo = Initializer.StructInfo;
370	break;
371	}
372	return *this;
373	}
374
375	/// The concrete assembly parser instance.
376	// Note that this is a full MCAsmParser, not an MCAsmParserExtension!
377	// It's a peer of AsmParser, not of COFFAsmParser, WasmAsmParser, etc.
378	class MasmParser : public MCAsmParser {
379	private:
380	AsmLexer Lexer;
381	MCContext &Ctx;
382	MCStreamer &Out;
383	const MCAsmInfo &MAI;
384	SourceMgr &SrcMgr;
385	SourceMgr::DiagHandlerTy SavedDiagHandler;
386	void *SavedDiagContext;
387	std::unique_ptr<MCAsmParserExtension> PlatformParser;
388
389	/// This is the current buffer index we're lexing from as managed by the
390	/// SourceMgr object.
391	unsigned CurBuffer;
392
393	/// time of assembly
394	struct tm TM;
395
396	BitVector EndStatementAtEOFStack;
397
398	AsmCond TheCondState;
399	std::vector<AsmCond> TheCondStack;
400
401	/// maps directive names to handler methods in parser
402	/// extensions. Extensions register themselves in this map by calling
403	/// addDirectiveHandler.
404	StringMap<ExtensionDirectiveHandler> ExtensionDirectiveMap;
405
406	/// maps assembly-time variable names to variables.
407	struct Variable {
408	enum RedefinableKind { NOT_REDEFINABLE, WARN_ON_REDEFINITION, REDEFINABLE };
409
410	StringRef Name;
411	RedefinableKind Redefinable = REDEFINABLE;
412	bool IsText = false;
413	std::string TextValue;
414	};
415	StringMap<Variable> Variables;
416
417	/// Stack of active struct definitions.
418	SmallVector<StructInfo, 1> StructInProgress;
419
420	/// Maps struct tags to struct definitions.
421	StringMap<StructInfo> Structs;
422
423	/// Maps data location names to types.
424	StringMap<AsmTypeInfo> KnownType;
425
426	/// Stack of active macro instantiations.
427	std::vector<MacroInstantiation*> ActiveMacros;
428
429	/// List of bodies of anonymous macros.
430	std::deque<MCAsmMacro> MacroLikeBodies;
431
432	/// Keeps track of how many .macro's have been instantiated.
433	unsigned NumOfMacroInstantiations;
434
435	/// The values from the last parsed cpp hash file line comment if any.
436	struct CppHashInfoTy {
437	StringRef Filename;
438	int64_t LineNumber;
439	SMLoc Loc;
440	unsigned Buf;
441	CppHashInfoTy() : LineNumber(0), Buf(0) {}
442	};
443	CppHashInfoTy CppHashInfo;
444
445	/// The filename from the first cpp hash file line comment, if any.
446	StringRef FirstCppHashFilename;
447
448	/// List of forward directional labels for diagnosis at the end.
449	SmallVector<std::tuple<SMLoc, CppHashInfoTy, MCSymbol *>, 4> DirLabels;
450
451	/// AssemblerDialect. ~OU means unset value and use value provided by MAI.
452	/// Defaults to 1U, meaning Intel.
453	unsigned AssemblerDialect = 1U;
454
455	/// is Darwin compatibility enabled?
456	bool IsDarwin = false;
457
458	/// Are we parsing ms-style inline assembly?
459	bool ParsingMSInlineAsm = false;
460
461	/// Did we already inform the user about inconsistent MD5 usage?
462	bool ReportedInconsistentMD5 = false;
463
464	// Current <...> expression depth.
465	unsigned AngleBracketDepth = 0U;
466
467	// Number of locals defined.
468	uint16_t LocalCounter = 0;
469
470	public:
471	MasmParser(SourceMgr &SM, MCContext &Ctx, MCStreamer &Out,
472	const MCAsmInfo &MAI, struct tm TM, unsigned CB = 0);
473	MasmParser(const MasmParser &) = delete;
474	MasmParser &operator=(const MasmParser &) = delete;
475	~MasmParser() override;
476
477	bool Run(bool NoInitialTextSection, bool NoFinalize = false) override;
478
479	void addDirectiveHandler(StringRef Directive,
480	ExtensionDirectiveHandler Handler) override {
481	ExtensionDirectiveMap[Directive] = Handler;
482	if (!DirectiveKindMap.contains(Key: Directive)) {
483	DirectiveKindMap[Directive] = DK_HANDLER_DIRECTIVE;
484	}
485	}
486
487	void addAliasForDirective(StringRef Directive, StringRef Alias) override {
488	DirectiveKindMap[Directive] = DirectiveKindMap[Alias];
489	}
490
491	/// @name MCAsmParser Interface
492	/// {
493
494	SourceMgr &getSourceManager() override { return SrcMgr; }
495	MCAsmLexer &getLexer() override { return Lexer; }
496	MCContext &getContext() override { return Ctx; }
497	MCStreamer &getStreamer() override { return Out; }
498
499	CodeViewContext &getCVContext() { return Ctx.getCVContext(); }
500
501	unsigned getAssemblerDialect() override {
502	if (AssemblerDialect == ~0U)
503	return MAI.getAssemblerDialect();
504	else
505	return AssemblerDialect;
506	}
507	void setAssemblerDialect(unsigned i) override {
508	AssemblerDialect = i;
509	}
510
511	void Note(SMLoc L, const Twine &Msg, SMRange Range = std::nullopt) override;
512	bool Warning(SMLoc L, const Twine &Msg,
513	SMRange Range = std::nullopt) override;
514	bool printError(SMLoc L, const Twine &Msg,
515	SMRange Range = std::nullopt) override;
516
517	enum ExpandKind { ExpandMacros, DoNotExpandMacros };
518	const AsmToken &Lex(ExpandKind ExpandNextToken);
519	const AsmToken &Lex() override { return Lex(ExpandNextToken: ExpandMacros); }
520
521	void setParsingMSInlineAsm(bool V) override {
522	ParsingMSInlineAsm = V;
523	// When parsing MS inline asm, we must lex 0b1101 and 0ABCH as binary and
524	// hex integer literals.
525	Lexer.setLexMasmIntegers(V);
526	}
527	bool isParsingMSInlineAsm() override { return ParsingMSInlineAsm; }
528
529	bool isParsingMasm() const override { return true; }
530
531	bool defineMacro(StringRef Name, StringRef Value) override;
532
533	bool lookUpField(StringRef Name, AsmFieldInfo &Info) const override;
534	bool lookUpField(StringRef Base, StringRef Member,
535	AsmFieldInfo &Info) const override;
536
537	bool lookUpType(StringRef Name, AsmTypeInfo &Info) const override;
538
539	bool parseMSInlineAsm(std::string &AsmString, unsigned &NumOutputs,
540	unsigned &NumInputs,
541	SmallVectorImpl<std::pair<void *, bool>> &OpDecls,
542	SmallVectorImpl<std::string> &Constraints,
543	SmallVectorImpl<std::string> &Clobbers,
544	const MCInstrInfo *MII, const MCInstPrinter *IP,
545	MCAsmParserSemaCallback &SI) override;
546
547	bool parseExpression(const MCExpr *&Res);
548	bool parseExpression(const MCExpr *&Res, SMLoc &EndLoc) override;
549	bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
550	AsmTypeInfo *TypeInfo) override;
551	bool parseParenExpression(const MCExpr *&Res, SMLoc &EndLoc) override;
552	bool parseParenExprOfDepth(unsigned ParenDepth, const MCExpr *&Res,
553	SMLoc &EndLoc) override;
554	bool parseAbsoluteExpression(int64_t &Res) override;
555
556	/// Parse a floating point expression using the float \p Semantics
557	/// and set \p Res to the value.
558	bool parseRealValue(const fltSemantics &Semantics, APInt &Res);
559
560	/// Parse an identifier or string (as a quoted identifier)
561	/// and set \p Res to the identifier contents.
562	enum IdentifierPositionKind { StandardPosition, StartOfStatement };
563	bool parseIdentifier(StringRef &Res, IdentifierPositionKind Position);
564	bool parseIdentifier(StringRef &Res) override {
565	return parseIdentifier(Res, Position: StandardPosition);
566	}
567	void eatToEndOfStatement() override;
568
569	bool checkForValidSection() override;
570
571	/// }
572
573	private:
574	bool expandMacros();
575	const AsmToken peekTok(bool ShouldSkipSpace = true);
576
577	bool parseStatement(ParseStatementInfo &Info,
578	MCAsmParserSemaCallback *SI);
579	bool parseCurlyBlockScope(SmallVectorImpl<AsmRewrite>& AsmStrRewrites);
580	bool parseCppHashLineFilenameComment(SMLoc L);
581
582	bool expandMacro(raw_svector_ostream &OS, StringRef Body,
583	ArrayRef<MCAsmMacroParameter> Parameters,
584	ArrayRef<MCAsmMacroArgument> A,
585	const std::vector<std::string> &Locals, SMLoc L);
586
587	/// Are we inside a macro instantiation?
588	bool isInsideMacroInstantiation() {return !ActiveMacros.empty();}
589
590	/// Handle entry to macro instantiation.
591	///
592	/// \param M The macro.
593	/// \param NameLoc Instantiation location.
594	bool handleMacroEntry(
595	const MCAsmMacro *M, SMLoc NameLoc,
596	AsmToken::TokenKind ArgumentEndTok = AsmToken::EndOfStatement);
597
598	/// Handle invocation of macro function.
599	///
600	/// \param M The macro.
601	/// \param NameLoc Invocation location.
602	bool handleMacroInvocation(const MCAsmMacro *M, SMLoc NameLoc);
603
604	/// Handle exit from macro instantiation.
605	void handleMacroExit();
606
607	/// Extract AsmTokens for a macro argument.
608	bool
609	parseMacroArgument(const MCAsmMacroParameter *MP, MCAsmMacroArgument &MA,
610	AsmToken::TokenKind EndTok = AsmToken::EndOfStatement);
611
612	/// Parse all macro arguments for a given macro.
613	bool
614	parseMacroArguments(const MCAsmMacro *M, MCAsmMacroArguments &A,
615	AsmToken::TokenKind EndTok = AsmToken::EndOfStatement);
616
617	void printMacroInstantiations();
618
619	bool expandStatement(SMLoc Loc);
620
621	void printMessage(SMLoc Loc, SourceMgr::DiagKind Kind, const Twine &Msg,
622	SMRange Range = std::nullopt) const {
623	ArrayRef<SMRange> Ranges(Range);
624	SrcMgr.PrintMessage(Loc, Kind, Msg, Ranges);
625	}
626	static void DiagHandler(const SMDiagnostic &Diag, void *Context);
627
628	bool lookUpField(const StructInfo &Structure, StringRef Member,
629	AsmFieldInfo &Info) const;
630
631	/// Should we emit DWARF describing this assembler source? (Returns false if
632	/// the source has .file directives, which means we don't want to generate
633	/// info describing the assembler source itself.)
634	bool enabledGenDwarfForAssembly();
635
636	/// Enter the specified file. This returns true on failure.
637	bool enterIncludeFile(const std::string &Filename);
638
639	/// Reset the current lexer position to that given by \p Loc. The
640	/// current token is not set; clients should ensure Lex() is called
641	/// subsequently.
642	///
643	/// \param InBuffer If not 0, should be the known buffer id that contains the
644	/// location.
645	void jumpToLoc(SMLoc Loc, unsigned InBuffer = 0,
646	bool EndStatementAtEOF = true);
647
648	/// Parse up to a token of kind \p EndTok and return the contents from the
649	/// current token up to (but not including) this token; the current token on
650	/// exit will be either this kind or EOF. Reads through instantiated macro
651	/// functions and text macros.
652	SmallVector<StringRef, 1> parseStringRefsTo(AsmToken::TokenKind EndTok);
653	std::string parseStringTo(AsmToken::TokenKind EndTok);
654
655	/// Parse up to the end of statement and return the contents from the current
656	/// token until the end of the statement; the current token on exit will be
657	/// either the EndOfStatement or EOF.
658	StringRef parseStringToEndOfStatement() override;
659
660	bool parseTextItem(std::string &Data);
661
662	unsigned getBinOpPrecedence(AsmToken::TokenKind K,
663	MCBinaryExpr::Opcode &Kind);
664
665	bool parseBinOpRHS(unsigned Precedence, const MCExpr *&Res, SMLoc &EndLoc);
666	bool parseParenExpr(const MCExpr *&Res, SMLoc &EndLoc);
667	bool parseBracketExpr(const MCExpr *&Res, SMLoc &EndLoc);
668
669	bool parseRegisterOrRegisterNumber(int64_t &Register, SMLoc DirectiveLoc);
670
671	bool parseCVFunctionId(int64_t &FunctionId, StringRef DirectiveName);
672	bool parseCVFileId(int64_t &FileId, StringRef DirectiveName);
673
674	// Generic (target and platform independent) directive parsing.
675	enum DirectiveKind {
676	DK_NO_DIRECTIVE, // Placeholder
677	DK_HANDLER_DIRECTIVE,
678	DK_ASSIGN,
679	DK_EQU,
680	DK_TEXTEQU,
681	DK_ASCII,
682	DK_ASCIZ,
683	DK_STRING,
684	DK_BYTE,
685	DK_SBYTE,
686	DK_WORD,
687	DK_SWORD,
688	DK_DWORD,
689	DK_SDWORD,
690	DK_FWORD,
691	DK_QWORD,
692	DK_SQWORD,
693	DK_DB,
694	DK_DD,
695	DK_DF,
696	DK_DQ,
697	DK_DW,
698	DK_REAL4,
699	DK_REAL8,
700	DK_REAL10,
701	DK_ALIGN,
702	DK_EVEN,
703	DK_ORG,
704	DK_ENDR,
705	DK_EXTERN,
706	DK_PUBLIC,
707	DK_COMM,
708	DK_COMMENT,
709	DK_INCLUDE,
710	DK_REPEAT,
711	DK_WHILE,
712	DK_FOR,
713	DK_FORC,
714	DK_IF,
715	DK_IFE,
716	DK_IFB,
717	DK_IFNB,
718	DK_IFDEF,
719	DK_IFNDEF,
720	DK_IFDIF,
721	DK_IFDIFI,
722	DK_IFIDN,
723	DK_IFIDNI,
724	DK_ELSEIF,
725	DK_ELSEIFE,
726	DK_ELSEIFB,
727	DK_ELSEIFNB,
728	DK_ELSEIFDEF,
729	DK_ELSEIFNDEF,
730	DK_ELSEIFDIF,
731	DK_ELSEIFDIFI,
732	DK_ELSEIFIDN,
733	DK_ELSEIFIDNI,
734	DK_ELSE,
735	DK_ENDIF,
736	DK_FILE,
737	DK_LINE,
738	DK_LOC,
739	DK_STABS,
740	DK_CV_FILE,
741	DK_CV_FUNC_ID,
742	DK_CV_INLINE_SITE_ID,
743	DK_CV_LOC,
744	DK_CV_LINETABLE,
745	DK_CV_INLINE_LINETABLE,
746	DK_CV_DEF_RANGE,
747	DK_CV_STRINGTABLE,
748	DK_CV_STRING,
749	DK_CV_FILECHECKSUMS,
750	DK_CV_FILECHECKSUM_OFFSET,
751	DK_CV_FPO_DATA,
752	DK_CFI_SECTIONS,
753	DK_CFI_STARTPROC,
754	DK_CFI_ENDPROC,
755	DK_CFI_DEF_CFA,
756	DK_CFI_DEF_CFA_OFFSET,
757	DK_CFI_ADJUST_CFA_OFFSET,
758	DK_CFI_DEF_CFA_REGISTER,
759	DK_CFI_OFFSET,
760	DK_CFI_REL_OFFSET,
761	DK_CFI_PERSONALITY,
762	DK_CFI_LSDA,
763	DK_CFI_REMEMBER_STATE,
764	DK_CFI_RESTORE_STATE,
765	DK_CFI_SAME_VALUE,
766	DK_CFI_RESTORE,
767	DK_CFI_ESCAPE,
768	DK_CFI_RETURN_COLUMN,
769	DK_CFI_SIGNAL_FRAME,
770	DK_CFI_UNDEFINED,
771	DK_CFI_REGISTER,
772	DK_CFI_WINDOW_SAVE,
773	DK_CFI_B_KEY_FRAME,
774	DK_MACRO,
775	DK_EXITM,
776	DK_ENDM,
777	DK_PURGE,
778	DK_ERR,
779	DK_ERRB,
780	DK_ERRNB,
781	DK_ERRDEF,
782	DK_ERRNDEF,
783	DK_ERRDIF,
784	DK_ERRDIFI,
785	DK_ERRIDN,
786	DK_ERRIDNI,
787	DK_ERRE,
788	DK_ERRNZ,
789	DK_ECHO,
790	DK_STRUCT,
791	DK_UNION,
792	DK_ENDS,
793	DK_END,
794	DK_PUSHFRAME,
795	DK_PUSHREG,
796	DK_SAVEREG,
797	DK_SAVEXMM128,
798	DK_SETFRAME,
799	DK_RADIX,
800	};
801
802	/// Maps directive name --> DirectiveKind enum, for directives parsed by this
803	/// class.
804	StringMap<DirectiveKind> DirectiveKindMap;
805
806	bool isMacroLikeDirective();
807
808	// Codeview def_range type parsing.
809	enum CVDefRangeType {
810	CVDR_DEFRANGE = 0, // Placeholder
811	CVDR_DEFRANGE_REGISTER,
812	CVDR_DEFRANGE_FRAMEPOINTER_REL,
813	CVDR_DEFRANGE_SUBFIELD_REGISTER,
814	CVDR_DEFRANGE_REGISTER_REL
815	};
816
817	/// Maps Codeview def_range types --> CVDefRangeType enum, for Codeview
818	/// def_range types parsed by this class.
819	StringMap<CVDefRangeType> CVDefRangeTypeMap;
820
821	// Generic (target and platform independent) directive parsing.
822	enum BuiltinSymbol {
823	BI_NO_SYMBOL, // Placeholder
824	BI_DATE,
825	BI_TIME,
826	BI_VERSION,
827	BI_FILECUR,
828	BI_FILENAME,
829	BI_LINE,
830	BI_CURSEG,
831	BI_CPU,
832	BI_INTERFACE,
833	BI_CODE,
834	BI_DATA,
835	BI_FARDATA,
836	BI_WORDSIZE,
837	BI_CODESIZE,
838	BI_DATASIZE,
839	BI_MODEL,
840	BI_STACK,
841	};
842
843	/// Maps builtin name --> BuiltinSymbol enum, for builtins handled by this
844	/// class.
845	StringMap<BuiltinSymbol> BuiltinSymbolMap;
846
847	const MCExpr *evaluateBuiltinValue(BuiltinSymbol Symbol, SMLoc StartLoc);
848
849	std::optional<std::string> evaluateBuiltinTextMacro(BuiltinSymbol Symbol,
850	SMLoc StartLoc);
851
852	// ".ascii", ".asciz", ".string"
853	bool parseDirectiveAscii(StringRef IDVal, bool ZeroTerminated);
854
855	// "byte", "word", ...
856	bool emitIntValue(const MCExpr *Value, unsigned Size);
857	bool parseScalarInitializer(unsigned Size,
858	SmallVectorImpl<const MCExpr *> &Values,
859	unsigned StringPadLength = 0);
860	bool parseScalarInstList(
861	unsigned Size, SmallVectorImpl<const MCExpr *> &Values,
862	const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
863	bool emitIntegralValues(unsigned Size, unsigned *Count = nullptr);
864	bool addIntegralField(StringRef Name, unsigned Size);
865	bool parseDirectiveValue(StringRef IDVal, unsigned Size);
866	bool parseDirectiveNamedValue(StringRef TypeName, unsigned Size,
867	StringRef Name, SMLoc NameLoc);
868
869	// "real4", "real8", "real10"
870	bool emitRealValues(const fltSemantics &Semantics, unsigned *Count = nullptr);
871	bool addRealField(StringRef Name, const fltSemantics &Semantics, size_t Size);
872	bool parseDirectiveRealValue(StringRef IDVal, const fltSemantics &Semantics,
873	size_t Size);
874	bool parseRealInstList(
875	const fltSemantics &Semantics, SmallVectorImpl<APInt> &Values,
876	const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
877	bool parseDirectiveNamedRealValue(StringRef TypeName,
878	const fltSemantics &Semantics,
879	unsigned Size, StringRef Name,
880	SMLoc NameLoc);
881
882	bool parseOptionalAngleBracketOpen();
883	bool parseAngleBracketClose(const Twine &Msg = "expected '>'");
884
885	bool parseFieldInitializer(const FieldInfo &Field,
886	FieldInitializer &Initializer);
887	bool parseFieldInitializer(const FieldInfo &Field,
888	const IntFieldInfo &Contents,
889	FieldInitializer &Initializer);
890	bool parseFieldInitializer(const FieldInfo &Field,
891	const RealFieldInfo &Contents,
892	FieldInitializer &Initializer);
893	bool parseFieldInitializer(const FieldInfo &Field,
894	const StructFieldInfo &Contents,
895	FieldInitializer &Initializer);
896
897	bool parseStructInitializer(const StructInfo &Structure,
898	StructInitializer &Initializer);
899	bool parseStructInstList(
900	const StructInfo &Structure, std::vector<StructInitializer> &Initializers,
901	const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
902
903	bool emitFieldValue(const FieldInfo &Field);
904	bool emitFieldValue(const FieldInfo &Field, const IntFieldInfo &Contents);
905	bool emitFieldValue(const FieldInfo &Field, const RealFieldInfo &Contents);
906	bool emitFieldValue(const FieldInfo &Field, const StructFieldInfo &Contents);
907
908	bool emitFieldInitializer(const FieldInfo &Field,
909	const FieldInitializer &Initializer);
910	bool emitFieldInitializer(const FieldInfo &Field,
911	const IntFieldInfo &Contents,
912	const IntFieldInfo &Initializer);
913	bool emitFieldInitializer(const FieldInfo &Field,
914	const RealFieldInfo &Contents,
915	const RealFieldInfo &Initializer);
916	bool emitFieldInitializer(const FieldInfo &Field,
917	const StructFieldInfo &Contents,
918	const StructFieldInfo &Initializer);
919
920	bool emitStructInitializer(const StructInfo &Structure,
921	const StructInitializer &Initializer);
922
923	// User-defined types (structs, unions):
924	bool emitStructValues(const StructInfo &Structure, unsigned *Count = nullptr);
925	bool addStructField(StringRef Name, const StructInfo &Structure);
926	bool parseDirectiveStructValue(const StructInfo &Structure,
927	StringRef Directive, SMLoc DirLoc);
928	bool parseDirectiveNamedStructValue(const StructInfo &Structure,
929	StringRef Directive, SMLoc DirLoc,
930	StringRef Name);
931
932	// "=", "equ", "textequ"
933	bool parseDirectiveEquate(StringRef IDVal, StringRef Name,
934	DirectiveKind DirKind, SMLoc NameLoc);
935
936	bool parseDirectiveOrg(); // "org"
937
938	bool emitAlignTo(int64_t Alignment);
939	bool parseDirectiveAlign(); // "align"
940	bool parseDirectiveEven(); // "even"
941
942	// ".file", ".line", ".loc", ".stabs"
943	bool parseDirectiveFile(SMLoc DirectiveLoc);
944	bool parseDirectiveLine();
945	bool parseDirectiveLoc();
946	bool parseDirectiveStabs();
947
948	// ".cv_file", ".cv_func_id", ".cv_inline_site_id", ".cv_loc", ".cv_linetable",
949	// ".cv_inline_linetable", ".cv_def_range", ".cv_string"
950	bool parseDirectiveCVFile();
951	bool parseDirectiveCVFuncId();
952	bool parseDirectiveCVInlineSiteId();
953	bool parseDirectiveCVLoc();
954	bool parseDirectiveCVLinetable();
955	bool parseDirectiveCVInlineLinetable();
956	bool parseDirectiveCVDefRange();
957	bool parseDirectiveCVString();
958	bool parseDirectiveCVStringTable();
959	bool parseDirectiveCVFileChecksums();
960	bool parseDirectiveCVFileChecksumOffset();
961	bool parseDirectiveCVFPOData();
962
963	// .cfi directives
964	bool parseDirectiveCFIRegister(SMLoc DirectiveLoc);
965	bool parseDirectiveCFIWindowSave(SMLoc DirectiveLoc);
966	bool parseDirectiveCFISections();
967	bool parseDirectiveCFIStartProc();
968	bool parseDirectiveCFIEndProc();
969	bool parseDirectiveCFIDefCfaOffset(SMLoc DirectiveLoc);
970	bool parseDirectiveCFIDefCfa(SMLoc DirectiveLoc);
971	bool parseDirectiveCFIAdjustCfaOffset(SMLoc DirectiveLoc);
972	bool parseDirectiveCFIDefCfaRegister(SMLoc DirectiveLoc);
973	bool parseDirectiveCFIOffset(SMLoc DirectiveLoc);
974	bool parseDirectiveCFIRelOffset(SMLoc DirectiveLoc);
975	bool parseDirectiveCFIPersonalityOrLsda(bool IsPersonality);
976	bool parseDirectiveCFIRememberState(SMLoc DirectiveLoc);
977	bool parseDirectiveCFIRestoreState(SMLoc DirectiveLoc);
978	bool parseDirectiveCFISameValue(SMLoc DirectiveLoc);
979	bool parseDirectiveCFIRestore(SMLoc DirectiveLoc);
980	bool parseDirectiveCFIEscape(SMLoc DirectiveLoc);
981	bool parseDirectiveCFIReturnColumn(SMLoc DirectiveLoc);
982	bool parseDirectiveCFISignalFrame();
983	bool parseDirectiveCFIUndefined(SMLoc DirectiveLoc);
984
985	// macro directives
986	bool parseDirectivePurgeMacro(SMLoc DirectiveLoc);
987	bool parseDirectiveExitMacro(SMLoc DirectiveLoc, StringRef Directive,
988	std::string &Value);
989	bool parseDirectiveEndMacro(StringRef Directive);
990	bool parseDirectiveMacro(StringRef Name, SMLoc NameLoc);
991
992	bool parseDirectiveStruct(StringRef Directive, DirectiveKind DirKind,
993	StringRef Name, SMLoc NameLoc);
994	bool parseDirectiveNestedStruct(StringRef Directive, DirectiveKind DirKind);
995	bool parseDirectiveEnds(StringRef Name, SMLoc NameLoc);
996	bool parseDirectiveNestedEnds();
997
998	bool parseDirectiveExtern();
999
1000	/// Parse a directive like ".globl" which accepts a single symbol (which
1001	/// should be a label or an external).
1002	bool parseDirectiveSymbolAttribute(MCSymbolAttr Attr);
1003
1004	bool parseDirectiveComm(bool IsLocal); // ".comm" and ".lcomm"
1005
1006	bool parseDirectiveComment(SMLoc DirectiveLoc); // "comment"
1007
1008	bool parseDirectiveInclude(); // "include"
1009
1010	// "if" or "ife"
1011	bool parseDirectiveIf(SMLoc DirectiveLoc, DirectiveKind DirKind);
1012	// "ifb" or "ifnb", depending on ExpectBlank.
1013	bool parseDirectiveIfb(SMLoc DirectiveLoc, bool ExpectBlank);
1014	// "ifidn", "ifdif", "ifidni", or "ifdifi", depending on ExpectEqual and
1015	// CaseInsensitive.
1016	bool parseDirectiveIfidn(SMLoc DirectiveLoc, bool ExpectEqual,
1017	bool CaseInsensitive);
1018	// "ifdef" or "ifndef", depending on expect_defined
1019	bool parseDirectiveIfdef(SMLoc DirectiveLoc, bool expect_defined);
1020	// "elseif" or "elseife"
1021	bool parseDirectiveElseIf(SMLoc DirectiveLoc, DirectiveKind DirKind);
1022	// "elseifb" or "elseifnb", depending on ExpectBlank.
1023	bool parseDirectiveElseIfb(SMLoc DirectiveLoc, bool ExpectBlank);
1024	// ".elseifdef" or ".elseifndef", depending on expect_defined
1025	bool parseDirectiveElseIfdef(SMLoc DirectiveLoc, bool expect_defined);
1026	// "elseifidn", "elseifdif", "elseifidni", or "elseifdifi", depending on
1027	// ExpectEqual and CaseInsensitive.
1028	bool parseDirectiveElseIfidn(SMLoc DirectiveLoc, bool ExpectEqual,
1029	bool CaseInsensitive);
1030	bool parseDirectiveElse(SMLoc DirectiveLoc); // "else"
1031	bool parseDirectiveEndIf(SMLoc DirectiveLoc); // "endif"
1032	bool parseEscapedString(std::string &Data) override;
1033	bool parseAngleBracketString(std::string &Data) override;
1034
1035	// Macro-like directives
1036	MCAsmMacro *parseMacroLikeBody(SMLoc DirectiveLoc);
1037	void instantiateMacroLikeBody(MCAsmMacro *M, SMLoc DirectiveLoc,
1038	raw_svector_ostream &OS);
1039	void instantiateMacroLikeBody(MCAsmMacro *M, SMLoc DirectiveLoc,
1040	SMLoc ExitLoc, raw_svector_ostream &OS);
1041	bool parseDirectiveRepeat(SMLoc DirectiveLoc, StringRef Directive);
1042	bool parseDirectiveFor(SMLoc DirectiveLoc, StringRef Directive);
1043	bool parseDirectiveForc(SMLoc DirectiveLoc, StringRef Directive);
1044	bool parseDirectiveWhile(SMLoc DirectiveLoc);
1045
1046	// "_emit" or "__emit"
1047	bool parseDirectiveMSEmit(SMLoc DirectiveLoc, ParseStatementInfo &Info,
1048	size_t Len);
1049
1050	// "align"
1051	bool parseDirectiveMSAlign(SMLoc DirectiveLoc, ParseStatementInfo &Info);
1052
1053	// "end"
1054	bool parseDirectiveEnd(SMLoc DirectiveLoc);
1055
1056	// ".err"
1057	bool parseDirectiveError(SMLoc DirectiveLoc);
1058	// ".errb" or ".errnb", depending on ExpectBlank.
1059	bool parseDirectiveErrorIfb(SMLoc DirectiveLoc, bool ExpectBlank);
1060	// ".errdef" or ".errndef", depending on ExpectBlank.
1061	bool parseDirectiveErrorIfdef(SMLoc DirectiveLoc, bool ExpectDefined);
1062	// ".erridn", ".errdif", ".erridni", or ".errdifi", depending on ExpectEqual
1063	// and CaseInsensitive.
1064	bool parseDirectiveErrorIfidn(SMLoc DirectiveLoc, bool ExpectEqual,
1065	bool CaseInsensitive);
1066	// ".erre" or ".errnz", depending on ExpectZero.
1067	bool parseDirectiveErrorIfe(SMLoc DirectiveLoc, bool ExpectZero);
1068
1069	// ".radix"
1070	bool parseDirectiveRadix(SMLoc DirectiveLoc);
1071
1072	// "echo"
1073	bool parseDirectiveEcho(SMLoc DirectiveLoc);
1074
1075	void initializeDirectiveKindMap();
1076	void initializeCVDefRangeTypeMap();
1077	void initializeBuiltinSymbolMap();
1078	};
1079
1080	} // end anonymous namespace
1081
1082	namespace llvm {
1083
1084	extern cl::opt<unsigned> AsmMacroMaxNestingDepth;
1085
1086	extern MCAsmParserExtension *createCOFFMasmParser();
1087
1088	} // end namespace llvm
1089
1090	enum { DEFAULT_ADDRSPACE = 0 };
1091
1092	MasmParser::MasmParser(SourceMgr &SM, MCContext &Ctx, MCStreamer &Out,
1093	const MCAsmInfo &MAI, struct tm TM, unsigned CB)
1094	: Lexer(MAI), Ctx(Ctx), Out(Out), MAI(MAI), SrcMgr(SM),
1095	CurBuffer(CB ? CB : SM.getMainFileID()), TM(TM) {
1096	HadError = false;
1097	// Save the old handler.
1098	SavedDiagHandler = SrcMgr.getDiagHandler();
1099	SavedDiagContext = SrcMgr.getDiagContext();
1100	// Set our own handler which calls the saved handler.
1101	SrcMgr.setDiagHandler(DH: DiagHandler, Ctx: this);
1102	Lexer.setBuffer(Buf: SrcMgr.getMemoryBuffer(i: CurBuffer)->getBuffer());
1103	EndStatementAtEOFStack.push_back(Val: true);
1104
1105	// Initialize the platform / file format parser.
1106	switch (Ctx.getObjectFileType()) {
1107	case MCContext::IsCOFF:
1108	PlatformParser.reset(p: createCOFFMasmParser());
1109	break;
1110	default:
1111	report_fatal_error(reason: "llvm-ml currently supports only COFF output.");
1112	break;
1113	}
1114
1115	initializeDirectiveKindMap();
1116	PlatformParser->Initialize(Parser&: *this);
1117	initializeCVDefRangeTypeMap();
1118	initializeBuiltinSymbolMap();
1119
1120	NumOfMacroInstantiations = 0;
1121	}
1122
1123	MasmParser::~MasmParser() {
1124	assert((HadError || ActiveMacros.empty()) &&
1125	"Unexpected active macro instantiation!");
1126
1127	// Restore the saved diagnostics handler and context for use during
1128	// finalization.
1129	SrcMgr.setDiagHandler(DH: SavedDiagHandler, Ctx: SavedDiagContext);
1130	}
1131
1132	void MasmParser::printMacroInstantiations() {
1133	// Print the active macro instantiation stack.
1134	for (std::vector<MacroInstantiation *>::const_reverse_iterator
1135	it = ActiveMacros.rbegin(),
1136	ie = ActiveMacros.rend();
1137	it != ie; ++it)
1138	printMessage(Loc: (*it)->InstantiationLoc, Kind: SourceMgr::DK_Note,
1139	Msg: "while in macro instantiation");
1140	}
1141
1142	void MasmParser::Note(SMLoc L, const Twine &Msg, SMRange Range) {
1143	printPendingErrors();
1144	printMessage(Loc: L, Kind: SourceMgr::DK_Note, Msg, Range);
1145	printMacroInstantiations();
1146	}
1147
1148	bool MasmParser::Warning(SMLoc L, const Twine &Msg, SMRange Range) {
1149	if (getTargetParser().getTargetOptions().MCNoWarn)
1150	return false;
1151	if (getTargetParser().getTargetOptions().MCFatalWarnings)
1152	return Error(L, Msg, Range);
1153	printMessage(Loc: L, Kind: SourceMgr::DK_Warning, Msg, Range);
1154	printMacroInstantiations();
1155	return false;
1156	}
1157
1158	bool MasmParser::printError(SMLoc L, const Twine &Msg, SMRange Range) {
1159	HadError = true;
1160	printMessage(Loc: L, Kind: SourceMgr::DK_Error, Msg, Range);
1161	printMacroInstantiations();
1162	return true;
1163	}
1164
1165	bool MasmParser::enterIncludeFile(const std::string &Filename) {
1166	std::string IncludedFile;
1167	unsigned NewBuf =
1168	SrcMgr.AddIncludeFile(Filename, IncludeLoc: Lexer.getLoc(), IncludedFile);
1169	if (!NewBuf)
1170	return true;
1171
1172	CurBuffer = NewBuf;
1173	Lexer.setBuffer(Buf: SrcMgr.getMemoryBuffer(i: CurBuffer)->getBuffer());
1174	EndStatementAtEOFStack.push_back(Val: true);
1175	return false;
1176	}
1177
1178	void MasmParser::jumpToLoc(SMLoc Loc, unsigned InBuffer,
1179	bool EndStatementAtEOF) {
1180	CurBuffer = InBuffer ? InBuffer : SrcMgr.FindBufferContainingLoc(Loc);
1181	Lexer.setBuffer(Buf: SrcMgr.getMemoryBuffer(i: CurBuffer)->getBuffer(),
1182	ptr: Loc.getPointer(), EndStatementAtEOF);
1183	}
1184
1185	bool MasmParser::expandMacros() {
1186	const AsmToken &Tok = getTok();
1187	const std::string IDLower = Tok.getIdentifier().lower();
1188
1189	const llvm::MCAsmMacro *M = getContext().lookupMacro(Name: IDLower);
1190	if (M && M->IsFunction && peekTok().is(K: AsmToken::LParen)) {
1191	// This is a macro function invocation; expand it in place.
1192	const SMLoc MacroLoc = Tok.getLoc();
1193	const StringRef MacroId = Tok.getIdentifier();
1194	Lexer.Lex();
1195	if (handleMacroInvocation(M, NameLoc: MacroLoc)) {
1196	Lexer.UnLex(Token: AsmToken(AsmToken::Error, MacroId));
1197	Lexer.Lex();
1198	}
1199	return false;
1200	}
1201
1202	std::optional<std::string> ExpandedValue;
1203	auto BuiltinIt = BuiltinSymbolMap.find(Key: IDLower);
1204	if (BuiltinIt != BuiltinSymbolMap.end()) {
1205	ExpandedValue =
1206	evaluateBuiltinTextMacro(Symbol: BuiltinIt->getValue(), StartLoc: Tok.getLoc());
1207	} else {
1208	auto VarIt = Variables.find(Key: IDLower);
1209	if (VarIt != Variables.end() && VarIt->getValue().IsText) {
1210	ExpandedValue = VarIt->getValue().TextValue;
1211	}
1212	}
1213
1214	if (!ExpandedValue)
1215	return true;
1216	std::unique_ptr<MemoryBuffer> Instantiation =
1217	MemoryBuffer::getMemBufferCopy(InputData: *ExpandedValue, BufferName: "<instantiation>");
1218
1219	// Jump to the macro instantiation and prime the lexer.
1220	CurBuffer =
1221	SrcMgr.AddNewSourceBuffer(F: std::move(Instantiation), IncludeLoc: Tok.getEndLoc());
1222	Lexer.setBuffer(Buf: SrcMgr.getMemoryBuffer(i: CurBuffer)->getBuffer(), ptr: nullptr,
1223	/*EndStatementAtEOF=*/false);
1224	EndStatementAtEOFStack.push_back(Val: false);
1225	Lexer.Lex();
1226	return false;
1227	}
1228
1229	const AsmToken &MasmParser::Lex(ExpandKind ExpandNextToken) {
1230	if (Lexer.getTok().is(K: AsmToken::Error))
1231	Error(L: Lexer.getErrLoc(), Msg: Lexer.getErr());
1232
1233	// if it's a end of statement with a comment in it
1234	if (getTok().is(K: AsmToken::EndOfStatement)) {
1235	// if this is a line comment output it.
1236	if (!getTok().getString().empty() && getTok().getString().front() != '\n' &&
1237	getTok().getString().front() != '\r' && MAI.preserveAsmComments())
1238	Out.addExplicitComment(T: Twine(getTok().getString()));
1239	}
1240
1241	const AsmToken *tok = &Lexer.Lex();
1242	bool StartOfStatement = Lexer.isAtStartOfStatement();
1243
1244	while (ExpandNextToken == ExpandMacros && tok->is(K: AsmToken::Identifier)) {
1245	if (StartOfStatement) {
1246	AsmToken NextTok;
1247	MutableArrayRef<AsmToken> Buf(NextTok);
1248	size_t ReadCount = Lexer.peekTokens(Buf);
1249	if (ReadCount && NextTok.is(K: AsmToken::Identifier) &&
1250	(NextTok.getString().equals_insensitive(RHS: "equ") ||
1251	NextTok.getString().equals_insensitive(RHS: "textequ"))) {
1252	// This looks like an EQU or TEXTEQU directive; don't expand the
1253	// identifier, allowing for redefinitions.
1254	break;
1255	}
1256	}
1257	if (expandMacros())
1258	break;
1259	}
1260
1261	// Parse comments here to be deferred until end of next statement.
1262	while (tok->is(K: AsmToken::Comment)) {
1263	if (MAI.preserveAsmComments())
1264	Out.addExplicitComment(T: Twine(tok->getString()));
1265	tok = &Lexer.Lex();
1266	}
1267
1268	// Recognize and bypass line continuations.
1269	while (tok->is(K: AsmToken::BackSlash) &&
1270	peekTok().is(K: AsmToken::EndOfStatement)) {
1271	// Eat both the backslash and the end of statement.
1272	Lexer.Lex();
1273	tok = &Lexer.Lex();
1274	}
1275
1276	if (tok->is(K: AsmToken::Eof)) {
1277	// If this is the end of an included file, pop the parent file off the
1278	// include stack.
1279	SMLoc ParentIncludeLoc = SrcMgr.getParentIncludeLoc(i: CurBuffer);
1280	if (ParentIncludeLoc != SMLoc()) {
1281	EndStatementAtEOFStack.pop_back();
1282	jumpToLoc(Loc: ParentIncludeLoc, InBuffer: 0, EndStatementAtEOF: EndStatementAtEOFStack.back());
1283	return Lex();
1284	}
1285	EndStatementAtEOFStack.pop_back();
1286	assert(EndStatementAtEOFStack.empty());
1287	}
1288
1289	return *tok;
1290	}
1291
1292	const AsmToken MasmParser::peekTok(bool ShouldSkipSpace) {
1293	AsmToken Tok;
1294
1295	MutableArrayRef<AsmToken> Buf(Tok);
1296	size_t ReadCount = Lexer.peekTokens(Buf, ShouldSkipSpace);
1297
1298	if (ReadCount == 0) {
1299	// If this is the end of an included file, pop the parent file off the
1300	// include stack.
1301	SMLoc ParentIncludeLoc = SrcMgr.getParentIncludeLoc(i: CurBuffer);
1302	if (ParentIncludeLoc != SMLoc()) {
1303	EndStatementAtEOFStack.pop_back();
1304	jumpToLoc(Loc: ParentIncludeLoc, InBuffer: 0, EndStatementAtEOF: EndStatementAtEOFStack.back());
1305	return peekTok(ShouldSkipSpace);
1306	}
1307	EndStatementAtEOFStack.pop_back();
1308	assert(EndStatementAtEOFStack.empty());
1309	}
1310
1311	assert(ReadCount == 1);
1312	return Tok;
1313	}
1314
1315	bool MasmParser::enabledGenDwarfForAssembly() {
1316	// Check whether the user specified -g.
1317	if (!getContext().getGenDwarfForAssembly())
1318	return false;
1319	// If we haven't encountered any .file directives (which would imply that
1320	// the assembler source was produced with debug info already) then emit one
1321	// describing the assembler source file itself.
1322	if (getContext().getGenDwarfFileNumber() == 0) {
1323	// Use the first #line directive for this, if any. It's preprocessed, so
1324	// there is no checksum, and of course no source directive.
1325	if (!FirstCppHashFilename.empty())
1326	getContext().setMCLineTableRootFile(
1327	/*CUID=*/0, CompilationDir: getContext().getCompilationDir(), Filename: FirstCppHashFilename,
1328	/*Cksum=*/Checksum: std::nullopt, /*Source=*/std::nullopt);
1329	const MCDwarfFile &RootFile =
1330	getContext().getMCDwarfLineTable(/*CUID=*/0).getRootFile();
1331	getContext().setGenDwarfFileNumber(getStreamer().emitDwarfFileDirective(
1332	/*CUID=*/FileNo: 0, Directory: getContext().getCompilationDir(), Filename: RootFile.Name,
1333	Checksum: RootFile.Checksum, Source: RootFile.Source));
1334	}
1335	return true;
1336	}
1337
1338	bool MasmParser::Run(bool NoInitialTextSection, bool NoFinalize) {
1339	// Create the initial section, if requested.
1340	if (!NoInitialTextSection)
1341	Out.initSections(NoExecStack: false, STI: getTargetParser().getSTI());
1342
1343	// Prime the lexer.
1344	Lex();
1345
1346	HadError = false;
1347	AsmCond StartingCondState = TheCondState;
1348	SmallVector<AsmRewrite, 4> AsmStrRewrites;
1349
1350	// If we are generating dwarf for assembly source files save the initial text
1351	// section. (Don't use enabledGenDwarfForAssembly() here, as we aren't
1352	// emitting any actual debug info yet and haven't had a chance to parse any
1353	// embedded .file directives.)
1354	if (getContext().getGenDwarfForAssembly()) {
1355	MCSection *Sec = getStreamer().getCurrentSectionOnly();
1356	if (!Sec->getBeginSymbol()) {
1357	MCSymbol *SectionStartSym = getContext().createTempSymbol();
1358	getStreamer().emitLabel(Symbol: SectionStartSym);
1359	Sec->setBeginSymbol(SectionStartSym);
1360	}
1361	bool InsertResult = getContext().addGenDwarfSection(Sec);
1362	assert(InsertResult && ".text section should not have debug info yet");
1363	(void)InsertResult;
1364	}
1365
1366	getTargetParser().onBeginOfFile();
1367
1368	// While we have input, parse each statement.
1369	while (Lexer.isNot(K: AsmToken::Eof) ||
1370	SrcMgr.getParentIncludeLoc(i: CurBuffer) != SMLoc()) {
1371	// Skip through the EOF at the end of an inclusion.
1372	if (Lexer.is(K: AsmToken::Eof))
1373	Lex();
1374
1375	ParseStatementInfo Info(&AsmStrRewrites);
1376	bool Parsed = parseStatement(Info, SI: nullptr);
1377
1378	// If we have a Lexer Error we are on an Error Token. Load in Lexer Error
1379	// for printing ErrMsg via Lex() only if no (presumably better) parser error
1380	// exists.
1381	if (Parsed && !hasPendingError() && Lexer.getTok().is(K: AsmToken::Error)) {
1382	Lex();
1383	}
1384
1385	// parseStatement returned true so may need to emit an error.
1386	printPendingErrors();
1387
1388	// Skipping to the next line if needed.
1389	if (Parsed && !getLexer().isAtStartOfStatement())
1390	eatToEndOfStatement();
1391	}
1392
1393	getTargetParser().onEndOfFile();
1394	printPendingErrors();
1395
1396	// All errors should have been emitted.
1397	assert(!hasPendingError() && "unexpected error from parseStatement");
1398
1399	getTargetParser().flushPendingInstructions(Out&: getStreamer());
1400
1401	if (TheCondState.TheCond != StartingCondState.TheCond ||
1402	TheCondState.Ignore != StartingCondState.Ignore)
1403	printError(L: getTok().getLoc(), Msg: "unmatched .ifs or .elses");
1404	// Check to see there are no empty DwarfFile slots.
1405	const auto &LineTables = getContext().getMCDwarfLineTables();
1406	if (!LineTables.empty()) {
1407	unsigned Index = 0;
1408	for (const auto &File : LineTables.begin()->second.getMCDwarfFiles()) {
1409	if (File.Name.empty() && Index != 0)
1410	printError(L: getTok().getLoc(), Msg: "unassigned file number: " +
1411	Twine(Index) +
1412	" for .file directives");
1413	++Index;
1414	}
1415	}
1416
1417	// Check to see that all assembler local symbols were actually defined.
1418	// Targets that don't do subsections via symbols may not want this, though,
1419	// so conservatively exclude them. Only do this if we're finalizing, though,
1420	// as otherwise we won't necessarilly have seen everything yet.
1421	if (!NoFinalize) {
1422	if (MAI.hasSubsectionsViaSymbols()) {
1423	for (const auto &TableEntry : getContext().getSymbols()) {
1424	MCSymbol *Sym = TableEntry.getValue();
1425	// Variable symbols may not be marked as defined, so check those
1426	// explicitly. If we know it's a variable, we have a definition for
1427	// the purposes of this check.
1428	if (Sym->isTemporary() && !Sym->isVariable() && !Sym->isDefined())
1429	// FIXME: We would really like to refer back to where the symbol was
1430	// first referenced for a source location. We need to add something
1431	// to track that. Currently, we just point to the end of the file.
1432	printError(L: getTok().getLoc(), Msg: "assembler local symbol '" +
1433	Sym->getName() + "' not defined");
1434	}
1435	}
1436
1437	// Temporary symbols like the ones for directional jumps don't go in the
1438	// symbol table. They also need to be diagnosed in all (final) cases.
1439	for (std::tuple<SMLoc, CppHashInfoTy, MCSymbol *> &LocSym : DirLabels) {
1440	if (std::get<2>(t&: LocSym)->isUndefined()) {
1441	// Reset the state of any "# line file" directives we've seen to the
1442	// context as it was at the diagnostic site.
1443	CppHashInfo = std::get<1>(t&: LocSym);
1444	printError(L: std::get<0>(t&: LocSym), Msg: "directional label undefined");
1445	}
1446	}
1447	}
1448
1449	// Finalize the output stream if there are no errors and if the client wants
1450	// us to.
1451	if (!HadError && !NoFinalize)
1452	Out.finish(EndLoc: Lexer.getLoc());
1453
1454	return HadError || getContext().hadError();
1455	}
1456
1457	bool MasmParser::checkForValidSection() {
1458	if (!ParsingMSInlineAsm && !getStreamer().getCurrentSectionOnly()) {
1459	Out.initSections(NoExecStack: false, STI: getTargetParser().getSTI());
1460	return Error(L: getTok().getLoc(),
1461	Msg: "expected section directive before assembly directive");
1462	}
1463	return false;
1464	}
1465
1466	/// Throw away the rest of the line for testing purposes.
1467	void MasmParser::eatToEndOfStatement() {
1468	while (Lexer.isNot(K: AsmToken::EndOfStatement)) {
1469	if (Lexer.is(K: AsmToken::Eof)) {
1470	SMLoc ParentIncludeLoc = SrcMgr.getParentIncludeLoc(i: CurBuffer);
1471	if (ParentIncludeLoc == SMLoc()) {
1472	break;
1473	}
1474
1475	EndStatementAtEOFStack.pop_back();
1476	jumpToLoc(Loc: ParentIncludeLoc, InBuffer: 0, EndStatementAtEOF: EndStatementAtEOFStack.back());
1477	}
1478
1479	Lexer.Lex();
1480	}
1481
1482	// Eat EOL.
1483	if (Lexer.is(K: AsmToken::EndOfStatement))
1484	Lexer.Lex();
1485	}
1486
1487	SmallVector<StringRef, 1>
1488	MasmParser::parseStringRefsTo(AsmToken::TokenKind EndTok) {
1489	SmallVector<StringRef, 1> Refs;
1490	const char *Start = getTok().getLoc().getPointer();
1491	while (Lexer.isNot(K: EndTok)) {
1492	if (Lexer.is(K: AsmToken::Eof)) {
1493	SMLoc ParentIncludeLoc = SrcMgr.getParentIncludeLoc(i: CurBuffer);
1494	if (ParentIncludeLoc == SMLoc()) {
1495	break;
1496	}
1497	Refs.emplace_back(Args&: Start, Args: getTok().getLoc().getPointer() - Start);
1498
1499	EndStatementAtEOFStack.pop_back();
1500	jumpToLoc(Loc: ParentIncludeLoc, InBuffer: 0, EndStatementAtEOF: EndStatementAtEOFStack.back());
1501	Lexer.Lex();
1502	Start = getTok().getLoc().getPointer();
1503	} else {
1504	Lexer.Lex();
1505	}
1506	}
1507	Refs.emplace_back(Args&: Start, Args: getTok().getLoc().getPointer() - Start);
1508	return Refs;
1509	}
1510
1511	std::string MasmParser::parseStringTo(AsmToken::TokenKind EndTok) {
1512	SmallVector<StringRef, 1> Refs = parseStringRefsTo(EndTok);
1513	std::string Str;
1514	for (StringRef S : Refs) {
1515	Str.append(str: S.str());
1516	}
1517	return Str;
1518	}
1519
1520	StringRef MasmParser::parseStringToEndOfStatement() {
1521	const char *Start = getTok().getLoc().getPointer();
1522
1523	while (Lexer.isNot(K: AsmToken::EndOfStatement) && Lexer.isNot(K: AsmToken::Eof))
1524	Lexer.Lex();
1525
1526	const char *End = getTok().getLoc().getPointer();
1527	return StringRef(Start, End - Start);
1528	}
1529
1530	/// Parse a paren expression and return it.
1531	/// NOTE: This assumes the leading '(' has already been consumed.
1532	///
1533	/// parenexpr ::= expr)
1534	///
1535	bool MasmParser::parseParenExpr(const MCExpr *&Res, SMLoc &EndLoc) {
1536	if (parseExpression(Res))
1537	return true;
1538	EndLoc = Lexer.getTok().getEndLoc();
1539	return parseRParen();
1540	}
1541
1542	/// Parse a bracket expression and return it.
1543	/// NOTE: This assumes the leading '[' has already been consumed.
1544	///
1545	/// bracketexpr ::= expr]
1546	///
1547	bool MasmParser::parseBracketExpr(const MCExpr *&Res, SMLoc &EndLoc) {
1548	if (parseExpression(Res))
1549	return true;
1550	EndLoc = getTok().getEndLoc();
1551	if (parseToken(T: AsmToken::RBrac, Msg: "expected ']' in brackets expression"))
1552	return true;
1553	return false;
1554	}
1555
1556	/// Parse a primary expression and return it.
1557	/// primaryexpr ::= (parenexpr
1558	/// primaryexpr ::= symbol
1559	/// primaryexpr ::= number
1560	/// primaryexpr ::= '.'
1561	/// primaryexpr ::= ~,+,-,'not' primaryexpr
1562	/// primaryexpr ::= string
1563	/// (a string is interpreted as a 64-bit number in big-endian base-256)
1564	bool MasmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
1565	AsmTypeInfo *TypeInfo) {
1566	SMLoc FirstTokenLoc = getLexer().getLoc();
1567	AsmToken::TokenKind FirstTokenKind = Lexer.getKind();
1568	switch (FirstTokenKind) {
1569	default:
1570	return TokError(Msg: "unknown token in expression");
1571	// If we have an error assume that we've already handled it.
1572	case AsmToken::Error:
1573	return true;
1574	case AsmToken::Exclaim:
1575	Lex(); // Eat the operator.
1576	if (parsePrimaryExpr(Res, EndLoc, TypeInfo: nullptr))
1577	return true;
1578	Res = MCUnaryExpr::createLNot(Expr: Res, Ctx&: getContext(), Loc: FirstTokenLoc);
1579	return false;
1580	case AsmToken::Dollar:
1581	case AsmToken::At:
1582	case AsmToken::Identifier: {
1583	StringRef Identifier;
1584	if (parseIdentifier(Res&: Identifier)) {
1585	// We may have failed but $ may be a valid token.
1586	if (getTok().is(K: AsmToken::Dollar)) {
1587	if (Lexer.getMAI().getDollarIsPC()) {
1588	Lex();
1589	// This is a '$' reference, which references the current PC. Emit a
1590	// temporary label to the streamer and refer to it.
1591	MCSymbol *Sym = Ctx.createTempSymbol();
1592	Out.emitLabel(Symbol: Sym);
1593	Res = MCSymbolRefExpr::create(Symbol: Sym, Kind: MCSymbolRefExpr::VK_None,
1594	Ctx&: getContext());
1595	EndLoc = FirstTokenLoc;
1596	return false;
1597	}
1598	return Error(L: FirstTokenLoc, Msg: "invalid token in expression");
1599	}
1600	}
1601	// Parse named bitwise negation.
1602	if (Identifier.equals_insensitive(RHS: "not")) {
1603	if (parsePrimaryExpr(Res, EndLoc, TypeInfo: nullptr))
1604	return true;
1605	Res = MCUnaryExpr::createNot(Expr: Res, Ctx&: getContext(), Loc: FirstTokenLoc);
1606	return false;
1607	}
1608	// Parse directional local label references.
1609	if (Identifier.equals_insensitive(RHS: "@b") ||
1610	Identifier.equals_insensitive(RHS: "@f")) {
1611	bool Before = Identifier.equals_insensitive(RHS: "@b");
1612	MCSymbol *Sym = getContext().getDirectionalLocalSymbol(LocalLabelVal: 0, Before);
1613	if (Before && Sym->isUndefined())
1614	return Error(L: FirstTokenLoc, Msg: "Expected @@ label before @B reference");
1615	Res = MCSymbolRefExpr::create(Symbol: Sym, Ctx&: getContext());
1616	return false;
1617	}
1618	// Parse symbol variant.
1619	std::pair<StringRef, StringRef> Split;
1620	if (!MAI.useParensForSymbolVariant()) {
1621	Split = Identifier.split(Separator: '@');
1622	} else if (Lexer.is(K: AsmToken::LParen)) {
1623	Lex(); // eat '('.
1624	StringRef VName;
1625	parseIdentifier(Res&: VName);
1626	// eat ')'.
1627	if (parseToken(T: AsmToken::RParen,
1628	Msg: "unexpected token in variant, expected ')'"))
1629	return true;
1630	Split = std::make_pair(x&: Identifier, y&: VName);
1631	}
1632
1633	EndLoc = SMLoc::getFromPointer(Ptr: Identifier.end());
1634
1635	// This is a symbol reference.
1636	StringRef SymbolName = Identifier;
1637	if (SymbolName.empty())
1638	return Error(L: getLexer().getLoc(), Msg: "expected a symbol reference");
1639
1640	MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
1641
1642	// Look up the symbol variant if used.
1643	if (!Split.second.empty()) {
1644	Variant = MCSymbolRefExpr::getVariantKindForName(Name: Split.second);
1645	if (Variant != MCSymbolRefExpr::VK_Invalid) {
1646	SymbolName = Split.first;
1647	} else if (MAI.doesAllowAtInName() && !MAI.useParensForSymbolVariant()) {
1648	Variant = MCSymbolRefExpr::VK_None;
1649	} else {
1650	return Error(L: SMLoc::getFromPointer(Ptr: Split.second.begin()),
1651	Msg: "invalid variant '" + Split.second + "'");
1652	}
1653	}
1654
1655	// Find the field offset if used.
1656	AsmFieldInfo Info;
1657	Split = SymbolName.split(Separator: '.');
1658	if (Split.second.empty()) {
1659	} else {
1660	SymbolName = Split.first;
1661	if (lookUpField(Base: SymbolName, Member: Split.second, Info)) {
1662	std::pair<StringRef, StringRef> BaseMember = Split.second.split(Separator: '.');
1663	StringRef Base = BaseMember.first, Member = BaseMember.second;
1664	lookUpField(Base, Member, Info);
1665	} else if (Structs.count(Key: SymbolName.lower())) {
1666	// This is actually a reference to a field offset.
1667	Res = MCConstantExpr::create(Value: Info.Offset, Ctx&: getContext());
1668	return false;
1669	}
1670	}
1671
1672	MCSymbol *Sym = getContext().getInlineAsmLabel(Name: SymbolName);
1673	if (!Sym) {
1674	// If this is a built-in numeric value, treat it as a constant.
1675	auto BuiltinIt = BuiltinSymbolMap.find(Key: SymbolName.lower());
1676	const BuiltinSymbol Symbol = (BuiltinIt == BuiltinSymbolMap.end())
1677	? BI_NO_SYMBOL
1678	: BuiltinIt->getValue();
1679	if (Symbol != BI_NO_SYMBOL) {
1680	const MCExpr *Value = evaluateBuiltinValue(Symbol, StartLoc: FirstTokenLoc);
1681	if (Value) {
1682	Res = Value;
1683	return false;
1684	}
1685	}
1686
1687	// Variables use case-insensitive symbol names; if this is a variable, we
1688	// find the symbol using its canonical name.
1689	auto VarIt = Variables.find(Key: SymbolName.lower());
1690	if (VarIt != Variables.end())
1691	SymbolName = VarIt->second.Name;
1692	Sym = getContext().getOrCreateSymbol(Name: SymbolName);
1693	}
1694
1695	// If this is an absolute variable reference, substitute it now to preserve
1696	// semantics in the face of reassignment.
1697	if (Sym->isVariable()) {
1698	auto V = Sym->getVariableValue(/*SetUsed=*/false);
1699	bool DoInline = isa<MCConstantExpr>(Val: V) && !Variant;
1700	if (auto TV = dyn_cast<MCTargetExpr>(Val: V))
1701	DoInline = TV->inlineAssignedExpr();
1702	if (DoInline) {
1703	if (Variant)
1704	return Error(L: EndLoc, Msg: "unexpected modifier on variable reference");
1705	Res = Sym->getVariableValue(/*SetUsed=*/false);
1706	return false;
1707	}
1708	}
1709
1710	// Otherwise create a symbol ref.
1711	const MCExpr *SymRef =
1712	MCSymbolRefExpr::create(Symbol: Sym, Kind: Variant, Ctx&: getContext(), Loc: FirstTokenLoc);
1713	if (Info.Offset) {
1714	Res = MCBinaryExpr::create(
1715	Op: MCBinaryExpr::Add, LHS: SymRef,
1716	RHS: MCConstantExpr::create(Value: Info.Offset, Ctx&: getContext()), Ctx&: getContext());
1717	} else {
1718	Res = SymRef;
1719	}
1720	if (TypeInfo) {
1721	if (Info.Type.Name.empty()) {
1722	auto TypeIt = KnownType.find(Key: Identifier.lower());
1723	if (TypeIt != KnownType.end()) {
1724	Info.Type = TypeIt->second;
1725	}
1726	}
1727
1728	*TypeInfo = Info.Type;
1729	}
1730	return false;
1731	}
1732	case AsmToken::BigNum:
1733	return TokError(Msg: "literal value out of range for directive");
1734	case AsmToken::Integer: {
1735	int64_t IntVal = getTok().getIntVal();
1736	Res = MCConstantExpr::create(Value: IntVal, Ctx&: getContext());
1737	EndLoc = Lexer.getTok().getEndLoc();
1738	Lex(); // Eat token.
1739	return false;
1740	}
1741	case AsmToken::String: {
1742	// MASM strings (used as constants) are interpreted as big-endian base-256.
1743	SMLoc ValueLoc = getTok().getLoc();
1744	std::string Value;
1745	if (parseEscapedString(Data&: Value))
1746	return true;
1747	if (Value.size() > 8)
1748	return Error(L: ValueLoc, Msg: "literal value out of range");
1749	uint64_t IntValue = 0;
1750	for (const unsigned char CharVal : Value)
1751	IntValue = (IntValue << 8) | CharVal;
1752	Res = MCConstantExpr::create(Value: IntValue, Ctx&: getContext());
1753	return false;
1754	}
1755	case AsmToken::Real: {
1756	APFloat RealVal(APFloat::IEEEdouble(), getTok().getString());
1757	uint64_t IntVal = RealVal.bitcastToAPInt().getZExtValue();
1758	Res = MCConstantExpr::create(Value: IntVal, Ctx&: getContext());
1759	EndLoc = Lexer.getTok().getEndLoc();
1760	Lex(); // Eat token.
1761	return false;
1762	}
1763	case AsmToken::Dot: {
1764	// This is a '.' reference, which references the current PC. Emit a
1765	// temporary label to the streamer and refer to it.
1766	MCSymbol *Sym = Ctx.createTempSymbol();
1767	Out.emitLabel(Symbol: Sym);
1768	Res = MCSymbolRefExpr::create(Symbol: Sym, Kind: MCSymbolRefExpr::VK_None, Ctx&: getContext());
1769	EndLoc = Lexer.getTok().getEndLoc();
1770	Lex(); // Eat identifier.
1771	return false;
1772	}
1773	case AsmToken::LParen:
1774	Lex(); // Eat the '('.
1775	return parseParenExpr(Res, EndLoc);
1776	case AsmToken::LBrac:
1777	if (!PlatformParser->HasBracketExpressions())
1778	return TokError(Msg: "brackets expression not supported on this target");
1779	Lex(); // Eat the '['.
1780	return parseBracketExpr(Res, EndLoc);
1781	case AsmToken::Minus:
1782	Lex(); // Eat the operator.
1783	if (parsePrimaryExpr(Res, EndLoc, TypeInfo: nullptr))
1784	return true;
1785	Res = MCUnaryExpr::createMinus(Expr: Res, Ctx&: getContext(), Loc: FirstTokenLoc);
1786	return false;
1787	case AsmToken::Plus:
1788	Lex(); // Eat the operator.
1789	if (parsePrimaryExpr(Res, EndLoc, TypeInfo: nullptr))
1790	return true;
1791	Res = MCUnaryExpr::createPlus(Expr: Res, Ctx&: getContext(), Loc: FirstTokenLoc);
1792	return false;
1793	case AsmToken::Tilde:
1794	Lex(); // Eat the operator.
1795	if (parsePrimaryExpr(Res, EndLoc, TypeInfo: nullptr))
1796	return true;
1797	Res = MCUnaryExpr::createNot(Expr: Res, Ctx&: getContext(), Loc: FirstTokenLoc);
1798	return false;
1799	// MIPS unary expression operators. The lexer won't generate these tokens if
1800	// MCAsmInfo::HasMipsExpressions is false for the target.
1801	case AsmToken::PercentCall16:
1802	case AsmToken::PercentCall_Hi:
1803	case AsmToken::PercentCall_Lo:
1804	case AsmToken::PercentDtprel_Hi:
1805	case AsmToken::PercentDtprel_Lo:
1806	case AsmToken::PercentGot:
1807	case AsmToken::PercentGot_Disp:
1808	case AsmToken::PercentGot_Hi:
1809	case AsmToken::PercentGot_Lo:
1810	case AsmToken::PercentGot_Ofst:
1811	case AsmToken::PercentGot_Page:
1812	case AsmToken::PercentGottprel:
1813	case AsmToken::PercentGp_Rel:
1814	case AsmToken::PercentHi:
1815	case AsmToken::PercentHigher:
1816	case AsmToken::PercentHighest:
1817	case AsmToken::PercentLo:
1818	case AsmToken::PercentNeg:
1819	case AsmToken::PercentPcrel_Hi:
1820	case AsmToken::PercentPcrel_Lo:
1821	case AsmToken::PercentTlsgd:
1822	case AsmToken::PercentTlsldm:
1823	case AsmToken::PercentTprel_Hi:
1824	case AsmToken::PercentTprel_Lo:
1825	Lex(); // Eat the operator.
1826	if (Lexer.isNot(K: AsmToken::LParen))
1827	return TokError(Msg: "expected '(' after operator");
1828	Lex(); // Eat the operator.
1829	if (parseExpression(Res, EndLoc))
1830	return true;
1831	if (parseRParen())
1832	return true;
1833	Res = getTargetParser().createTargetUnaryExpr(E: Res, OperatorToken: FirstTokenKind, Ctx);
1834	return !Res;
1835	}
1836	}
1837
1838	bool MasmParser::parseExpression(const MCExpr *&Res) {
1839	SMLoc EndLoc;
1840	return parseExpression(Res, EndLoc);
1841	}
1842
1843	/// This function checks if the next token is <string> type or arithmetic.
1844	/// string that begin with character '<' must end with character '>'.
1845	/// otherwise it is arithmetics.
1846	/// If the function returns a 'true' value,
1847	/// the End argument will be filled with the last location pointed to the '>'
1848	/// character.
1849	static bool isAngleBracketString(SMLoc &StrLoc, SMLoc &EndLoc) {
1850	assert((StrLoc.getPointer() != nullptr) &&
1851	"Argument to the function cannot be a NULL value");
1852	const char *CharPtr = StrLoc.getPointer();
1853	while ((*CharPtr != '>') && (*CharPtr != '\n') && (*CharPtr != '\r') &&
1854	(*CharPtr != '\0')) {
1855	if (*CharPtr == '!')
1856	CharPtr++;
1857	CharPtr++;
1858	}
1859	if (*CharPtr == '>') {
1860	EndLoc = StrLoc.getFromPointer(Ptr: CharPtr + 1);
1861	return true;
1862	}
1863	return false;
1864	}
1865
1866	/// creating a string without the escape characters '!'.
1867	static std::string angleBracketString(StringRef BracketContents) {
1868	std::string Res;
1869	for (size_t Pos = 0; Pos < BracketContents.size(); Pos++) {
1870	if (BracketContents[Pos] == '!')
1871	Pos++;
1872	Res += BracketContents[Pos];
1873	}
1874	return Res;
1875	}
1876
1877	/// Parse an expression and return it.
1878	///
1879	/// expr ::= expr &&,|| expr -> lowest.
1880	/// expr ::= expr |,^,&,! expr
1881	/// expr ::= expr ==,!=,<>,<,<=,>,>= expr
1882	/// expr ::= expr <<,>> expr
1883	/// expr ::= expr +,- expr
1884	/// expr ::= expr *,/,% expr -> highest.
1885	/// expr ::= primaryexpr
1886	///
1887	bool MasmParser::parseExpression(const MCExpr *&Res, SMLoc &EndLoc) {
1888	// Parse the expression.
1889	Res = nullptr;
1890	if (getTargetParser().parsePrimaryExpr(Res, EndLoc) ||
1891	parseBinOpRHS(Precedence: 1, Res, EndLoc))
1892	return true;
1893
1894	// Try to constant fold it up front, if possible. Do not exploit
1895	// assembler here.
1896	int64_t Value;
1897	if (Res->evaluateAsAbsolute(Res&: Value))
1898	Res = MCConstantExpr::create(Value, Ctx&: getContext());
1899
1900	return false;
1901	}
1902
1903	bool MasmParser::parseParenExpression(const MCExpr *&Res, SMLoc &EndLoc) {
1904	Res = nullptr;
1905	return parseParenExpr(Res, EndLoc) || parseBinOpRHS(Precedence: 1, Res, EndLoc);
1906	}
1907
1908	bool MasmParser::parseParenExprOfDepth(unsigned ParenDepth, const MCExpr *&Res,
1909	SMLoc &EndLoc) {
1910	if (parseParenExpr(Res, EndLoc))
1911	return true;
1912
1913	for (; ParenDepth > 0; --ParenDepth) {
1914	if (parseBinOpRHS(Precedence: 1, Res, EndLoc))
1915	return true;
1916
1917	// We don't Lex() the last RParen.
1918	// This is the same behavior as parseParenExpression().
1919	if (ParenDepth - 1 > 0) {
1920	EndLoc = getTok().getEndLoc();
1921	if (parseRParen())
1922	return true;
1923	}
1924	}
1925	return false;
1926	}
1927
1928	bool MasmParser::parseAbsoluteExpression(int64_t &Res) {
1929	const MCExpr *Expr;
1930
1931	SMLoc StartLoc = Lexer.getLoc();
1932	if (parseExpression(Res&: Expr))
1933	return true;
1934
1935	if (!Expr->evaluateAsAbsolute(Res, Asm: getStreamer().getAssemblerPtr()))
1936	return Error(L: StartLoc, Msg: "expected absolute expression");
1937
1938	return false;
1939	}
1940
1941	static unsigned getGNUBinOpPrecedence(AsmToken::TokenKind K,
1942	MCBinaryExpr::Opcode &Kind,
1943	bool ShouldUseLogicalShr,
1944	bool EndExpressionAtGreater) {
1945	switch (K) {
1946	default:
1947	return 0; // not a binop.
1948
1949	// Lowest Precedence: &&, ||
1950	case AsmToken::AmpAmp:
1951	Kind = MCBinaryExpr::LAnd;
1952	return 2;
1953	case AsmToken::PipePipe:
1954	Kind = MCBinaryExpr::LOr;
1955	return 1;
1956
1957	// Low Precedence: ==, !=, <>, <, <=, >, >=
1958	case AsmToken::EqualEqual:
1959	Kind = MCBinaryExpr::EQ;
1960	return 3;
1961	case AsmToken::ExclaimEqual:
1962	case AsmToken::LessGreater:
1963	Kind = MCBinaryExpr::NE;
1964	return 3;
1965	case AsmToken::Less:
1966	Kind = MCBinaryExpr::LT;
1967	return 3;
1968	case AsmToken::LessEqual:
1969	Kind = MCBinaryExpr::LTE;
1970	return 3;
1971	case AsmToken::Greater:
1972	if (EndExpressionAtGreater)
1973	return 0;
1974	Kind = MCBinaryExpr::GT;
1975	return 3;
1976	case AsmToken::GreaterEqual:
1977	Kind = MCBinaryExpr::GTE;
1978	return 3;
1979
1980	// Low Intermediate Precedence: +, -
1981	case AsmToken::Plus:
1982	Kind = MCBinaryExpr::Add;
1983	return 4;
1984	case AsmToken::Minus:
1985	Kind = MCBinaryExpr::Sub;
1986	return 4;
1987
1988	// High Intermediate Precedence: |, &, ^
1989	case AsmToken::Pipe:
1990	Kind = MCBinaryExpr::Or;
1991	return 5;
1992	case AsmToken::Caret:
1993	Kind = MCBinaryExpr::Xor;
1994	return 5;
1995	case AsmToken::Amp:
1996	Kind = MCBinaryExpr::And;
1997	return 5;
1998
1999	// Highest Precedence: *, /, %, <<, >>
2000	case AsmToken::Star:
2001	Kind = MCBinaryExpr::Mul;
2002	return 6;
2003	case AsmToken::Slash:
2004	Kind = MCBinaryExpr::Div;
2005	return 6;
2006	case AsmToken::Percent:
2007	Kind = MCBinaryExpr::Mod;
2008	return 6;
2009	case AsmToken::LessLess:
2010	Kind = MCBinaryExpr::Shl;
2011	return 6;
2012	case AsmToken::GreaterGreater:
2013	if (EndExpressionAtGreater)
2014	return 0;
2015	Kind = ShouldUseLogicalShr ? MCBinaryExpr::LShr : MCBinaryExpr::AShr;
2016	return 6;
2017	}
2018	}
2019
2020	unsigned MasmParser::getBinOpPrecedence(AsmToken::TokenKind K,
2021	MCBinaryExpr::Opcode &Kind) {
2022	bool ShouldUseLogicalShr = MAI.shouldUseLogicalShr();
2023	return getGNUBinOpPrecedence(K, Kind, ShouldUseLogicalShr,
2024	EndExpressionAtGreater: AngleBracketDepth > 0);
2025	}
2026
2027	/// Parse all binary operators with precedence >= 'Precedence'.
2028	/// Res contains the LHS of the expression on input.
2029	bool MasmParser::parseBinOpRHS(unsigned Precedence, const MCExpr *&Res,
2030	SMLoc &EndLoc) {
2031	SMLoc StartLoc = Lexer.getLoc();
2032	while (true) {
2033	AsmToken::TokenKind TokKind = Lexer.getKind();
2034	if (Lexer.getKind() == AsmToken::Identifier) {
2035	TokKind = StringSwitch<AsmToken::TokenKind>(Lexer.getTok().getString())
2036	.CaseLower(S: "and", Value: AsmToken::Amp)
2037	.CaseLower(S: "not", Value: AsmToken::Exclaim)
2038	.CaseLower(S: "or", Value: AsmToken::Pipe)
2039	.CaseLower(S: "xor", Value: AsmToken::Caret)
2040	.CaseLower(S: "shl", Value: AsmToken::LessLess)
2041	.CaseLower(S: "shr", Value: AsmToken::GreaterGreater)
2042	.CaseLower(S: "eq", Value: AsmToken::EqualEqual)
2043	.CaseLower(S: "ne", Value: AsmToken::ExclaimEqual)
2044	.CaseLower(S: "lt", Value: AsmToken::Less)
2045	.CaseLower(S: "le", Value: AsmToken::LessEqual)
2046	.CaseLower(S: "gt", Value: AsmToken::Greater)
2047	.CaseLower(S: "ge", Value: AsmToken::GreaterEqual)
2048	.Default(Value: TokKind);
2049	}
2050	MCBinaryExpr::Opcode Kind = MCBinaryExpr::Add;
2051	unsigned TokPrec = getBinOpPrecedence(K: TokKind, Kind);
2052
2053	// If the next token is lower precedence than we are allowed to eat, return
2054	// successfully with what we ate already.
2055	if (TokPrec < Precedence)
2056	return false;
2057
2058	Lex();
2059
2060	// Eat the next primary expression.
2061	const MCExpr *RHS;
2062	if (getTargetParser().parsePrimaryExpr(Res&: RHS, EndLoc))
2063	return true;
2064
2065	// If BinOp binds less tightly with RHS than the operator after RHS, let
2066	// the pending operator take RHS as its LHS.
2067	MCBinaryExpr::Opcode Dummy;
2068	unsigned NextTokPrec = getBinOpPrecedence(K: Lexer.getKind(), Kind&: Dummy);
2069	if (TokPrec < NextTokPrec && parseBinOpRHS(Precedence: TokPrec + 1, Res&: RHS, EndLoc))
2070	return true;
2071
2072	// Merge LHS and RHS according to operator.
2073	Res = MCBinaryExpr::create(Op: Kind, LHS: Res, RHS, Ctx&: getContext(), Loc: StartLoc);
2074	}
2075	}
2076
2077	/// ParseStatement:
2078	/// ::= % statement
2079	/// ::= EndOfStatement
2080	/// ::= Label* Directive ...Operands... EndOfStatement
2081	/// ::= Label* Identifier OperandList* EndOfStatement
2082	bool MasmParser::parseStatement(ParseStatementInfo &Info,
2083	MCAsmParserSemaCallback *SI) {
2084	assert(!hasPendingError() && "parseStatement started with pending error");
2085	// Eat initial spaces and comments.
2086	while (Lexer.is(K: AsmToken::Space))
2087	Lex();
2088	if (Lexer.is(K: AsmToken::EndOfStatement)) {
2089	// If this is a line comment we can drop it safely.
2090	if (getTok().getString().empty() || getTok().getString().front() == '\r' ||
2091	getTok().getString().front() == '\n')
2092	Out.addBlankLine();
2093	Lex();
2094	return false;
2095	}
2096
2097	// If preceded by an expansion operator, first expand all text macros and
2098	// macro functions.
2099	if (getTok().is(K: AsmToken::Percent)) {
2100	SMLoc ExpansionLoc = getTok().getLoc();
2101	if (parseToken(T: AsmToken::Percent) || expandStatement(Loc: ExpansionLoc))
2102	return true;
2103	}
2104
2105	// Statements always start with an identifier, unless we're dealing with a
2106	// processor directive (.386, .686, etc.) that lexes as a real.
2107	AsmToken ID = getTok();
2108	SMLoc IDLoc = ID.getLoc();
2109	StringRef IDVal;
2110	if (Lexer.is(K: AsmToken::HashDirective))
2111	return parseCppHashLineFilenameComment(L: IDLoc);
2112	if (Lexer.is(K: AsmToken::Dot)) {
2113	// Treat '.' as a valid identifier in this context.
2114	Lex();
2115	IDVal = ".";
2116	} else if (Lexer.is(K: AsmToken::Real)) {
2117	// Treat ".<number>" as a valid identifier in this context.
2118	IDVal = getTok().getString();
2119	Lex(); // always eat a token
2120	if (!IDVal.starts_with(Prefix: "."))
2121	return Error(L: IDLoc, Msg: "unexpected token at start of statement");
2122	} else if (parseIdentifier(Res&: IDVal, Position: StartOfStatement)) {
2123	if (!TheCondState.Ignore) {
2124	Lex(); // always eat a token
2125	return Error(L: IDLoc, Msg: "unexpected token at start of statement");
2126	}
2127	IDVal = "";
2128	}
2129
2130	// Handle conditional assembly here before checking for skipping. We
2131	// have to do this so that .endif isn't skipped in a ".if 0" block for
2132	// example.
2133	StringMap<DirectiveKind>::const_iterator DirKindIt =
2134	DirectiveKindMap.find(Key: IDVal.lower());
2135	DirectiveKind DirKind = (DirKindIt == DirectiveKindMap.end())
2136	? DK_NO_DIRECTIVE
2137	: DirKindIt->getValue();
2138	switch (DirKind) {
2139	default:
2140	break;
2141	case DK_IF:
2142	case DK_IFE:
2143	return parseDirectiveIf(DirectiveLoc: IDLoc, DirKind);
2144	case DK_IFB:
2145	return parseDirectiveIfb(DirectiveLoc: IDLoc, ExpectBlank: true);
2146	case DK_IFNB:
2147	return parseDirectiveIfb(DirectiveLoc: IDLoc, ExpectBlank: false);
2148	case DK_IFDEF:
2149	return parseDirectiveIfdef(DirectiveLoc: IDLoc, expect_defined: true);
2150	case DK_IFNDEF:
2151	return parseDirectiveIfdef(DirectiveLoc: IDLoc, expect_defined: false);
2152	case DK_IFDIF:
2153	return parseDirectiveIfidn(DirectiveLoc: IDLoc, /*ExpectEqual=*/false,
2154	/*CaseInsensitive=*/false);
2155	case DK_IFDIFI:
2156	return parseDirectiveIfidn(DirectiveLoc: IDLoc, /*ExpectEqual=*/false,
2157	/*CaseInsensitive=*/true);
2158	case DK_IFIDN:
2159	return parseDirectiveIfidn(DirectiveLoc: IDLoc, /*ExpectEqual=*/true,
2160	/*CaseInsensitive=*/false);
2161	case DK_IFIDNI:
2162	return parseDirectiveIfidn(DirectiveLoc: IDLoc, /*ExpectEqual=*/true,
2163	/*CaseInsensitive=*/true);
2164	case DK_ELSEIF:
2165	case DK_ELSEIFE:
2166	return parseDirectiveElseIf(DirectiveLoc: IDLoc, DirKind);
2167	case DK_ELSEIFB:
2168	return parseDirectiveElseIfb(DirectiveLoc: IDLoc, ExpectBlank: true);
2169	case DK_ELSEIFNB:
2170	return parseDirectiveElseIfb(DirectiveLoc: IDLoc, ExpectBlank: false);
2171	case DK_ELSEIFDEF:
2172	return parseDirectiveElseIfdef(DirectiveLoc: IDLoc, expect_defined: true);
2173	case DK_ELSEIFNDEF:
2174	return parseDirectiveElseIfdef(DirectiveLoc: IDLoc, expect_defined: false);
2175	case DK_ELSEIFDIF:
2176	return parseDirectiveElseIfidn(DirectiveLoc: IDLoc, /*ExpectEqual=*/false,
2177	/*CaseInsensitive=*/false);
2178	case DK_ELSEIFDIFI:
2179	return parseDirectiveElseIfidn(DirectiveLoc: IDLoc, /*ExpectEqual=*/false,
2180	/*CaseInsensitive=*/true);
2181	case DK_ELSEIFIDN:
2182	return parseDirectiveElseIfidn(DirectiveLoc: IDLoc, /*ExpectEqual=*/true,
2183	/*CaseInsensitive=*/false);
2184	case DK_ELSEIFIDNI:
2185	return parseDirectiveElseIfidn(DirectiveLoc: IDLoc, /*ExpectEqual=*/true,
2186	/*CaseInsensitive=*/true);
2187	case DK_ELSE:
2188	return parseDirectiveElse(DirectiveLoc: IDLoc);
2189	case DK_ENDIF:
2190	return parseDirectiveEndIf(DirectiveLoc: IDLoc);
2191	}
2192
2193	// Ignore the statement if in the middle of inactive conditional
2194	// (e.g. ".if 0").
2195	if (TheCondState.Ignore) {
2196	eatToEndOfStatement();
2197	return false;
2198	}
2199
2200	// FIXME: Recurse on local labels?
2201
2202	// Check for a label.
2203	// ::= identifier ':'
2204	// ::= number ':'
2205	if (Lexer.is(K: AsmToken::Colon) && getTargetParser().isLabel(Token&: ID)) {
2206	if (checkForValidSection())
2207	return true;
2208
2209	// identifier ':' -> Label.
2210	Lex();
2211
2212	// Diagnose attempt to use '.' as a label.
2213	if (IDVal == ".")
2214	return Error(L: IDLoc, Msg: "invalid use of pseudo-symbol '.' as a label");
2215
2216	// Diagnose attempt to use a variable as a label.
2217	//
2218	// FIXME: Diagnostics. Note the location of the definition as a label.
2219	// FIXME: This doesn't diagnose assignment to a symbol which has been
2220	// implicitly marked as external.
2221	MCSymbol *Sym;
2222	if (ParsingMSInlineAsm && SI) {
2223	StringRef RewrittenLabel =
2224	SI->LookupInlineAsmLabel(Identifier: IDVal, SM&: getSourceManager(), Location: IDLoc, Create: true);
2225	assert(!RewrittenLabel.empty() &&
2226	"We should have an internal name here.");
2227	Info.AsmRewrites->emplace_back(Args: AOK_Label, Args&: IDLoc, Args: IDVal.size(),
2228	Args&: RewrittenLabel);
2229	IDVal = RewrittenLabel;
2230	}
2231	// Handle directional local labels
2232	if (IDVal == "@@") {
2233	Sym = Ctx.createDirectionalLocalSymbol(LocalLabelVal: 0);
2234	} else {
2235	Sym = getContext().getOrCreateSymbol(Name: IDVal);
2236	}
2237
2238	// End of Labels should be treated as end of line for lexing
2239	// purposes but that information is not available to the Lexer who
2240	// does not understand Labels. This may cause us to see a Hash
2241	// here instead of a preprocessor line comment.
2242	if (getTok().is(K: AsmToken::Hash)) {
2243	std::string CommentStr = parseStringTo(EndTok: AsmToken::EndOfStatement);
2244	Lexer.Lex();
2245	Lexer.UnLex(Token: AsmToken(AsmToken::EndOfStatement, CommentStr));
2246	}
2247
2248	// Consume any end of statement token, if present, to avoid spurious
2249	// addBlankLine calls().
2250	if (getTok().is(K: AsmToken::EndOfStatement)) {
2251	Lex();
2252	}
2253
2254	getTargetParser().doBeforeLabelEmit(Symbol: Sym, IDLoc);
2255
2256	// Emit the label.
2257	if (!getTargetParser().isParsingMSInlineAsm())
2258	Out.emitLabel(Symbol: Sym, Loc: IDLoc);
2259
2260	// If we are generating dwarf for assembly source files then gather the
2261	// info to make a dwarf label entry for this label if needed.
2262	if (enabledGenDwarfForAssembly())
2263	MCGenDwarfLabelEntry::Make(Symbol: Sym, MCOS: &getStreamer(), SrcMgr&: getSourceManager(),
2264	Loc&: IDLoc);
2265
2266	getTargetParser().onLabelParsed(Symbol: Sym);
2267
2268	return false;
2269	}
2270
2271	// If macros are enabled, check to see if this is a macro instantiation.
2272	if (const MCAsmMacro *M = getContext().lookupMacro(Name: IDVal.lower())) {
2273	return handleMacroEntry(M, NameLoc: IDLoc);
2274	}
2275
2276	// Otherwise, we have a normal instruction or directive.
2277
2278	if (DirKind != DK_NO_DIRECTIVE) {
2279	// There are several entities interested in parsing directives:
2280	//
2281	// 1. Asm parser extensions. For example, platform-specific parsers
2282	// (like the ELF parser) register themselves as extensions.
2283	// 2. The target-specific assembly parser. Some directives are target
2284	// specific or may potentially behave differently on certain targets.
2285	// 3. The generic directive parser implemented by this class. These are
2286	// all the directives that behave in a target and platform independent
2287	// manner, or at least have a default behavior that's shared between
2288	// all targets and platforms.
2289
2290	getTargetParser().flushPendingInstructions(Out&: getStreamer());
2291
2292	// Special-case handling of structure-end directives at higher priority,
2293	// since ENDS is overloaded as a segment-end directive.
2294	if (IDVal.equals_insensitive(RHS: "ends") && StructInProgress.size() > 1 &&
2295	getTok().is(K: AsmToken::EndOfStatement)) {
2296	return parseDirectiveNestedEnds();
2297	}
2298
2299	// First, check the extension directive map to see if any extension has
2300	// registered itself to parse this directive.
2301	std::pair<MCAsmParserExtension *, DirectiveHandler> Handler =
2302	ExtensionDirectiveMap.lookup(Key: IDVal.lower());
2303	if (Handler.first)
2304	return (*Handler.second)(Handler.first, IDVal, IDLoc);
2305
2306	// Next, let the target-specific assembly parser try.
2307	if (ID.isNot(K: AsmToken::Identifier))
2308	return false;
2309
2310	ParseStatus TPDirectiveReturn = getTargetParser().parseDirective(DirectiveID: ID);
2311	assert(TPDirectiveReturn.isFailure() == hasPendingError() &&
2312	"Should only return Failure iff there was an error");
2313	if (TPDirectiveReturn.isFailure())
2314	return true;
2315	if (TPDirectiveReturn.isSuccess())
2316	return false;
2317
2318	// Finally, if no one else is interested in this directive, it must be
2319	// generic and familiar to this class.
2320	switch (DirKind) {
2321	default:
2322	break;
2323	case DK_ASCII:
2324	return parseDirectiveAscii(IDVal, ZeroTerminated: false);
2325	case DK_ASCIZ:
2326	case DK_STRING:
2327	return parseDirectiveAscii(IDVal, ZeroTerminated: true);
2328	case DK_BYTE:
2329	case DK_SBYTE:
2330	case DK_DB:
2331	return parseDirectiveValue(IDVal, Size: 1);
2332	case DK_WORD:
2333	case DK_SWORD:
2334	case DK_DW:
2335	return parseDirectiveValue(IDVal, Size: 2);
2336	case DK_DWORD:
2337	case DK_SDWORD:
2338	case DK_DD:
2339	return parseDirectiveValue(IDVal, Size: 4);
2340	case DK_FWORD:
2341	case DK_DF:
2342	return parseDirectiveValue(IDVal, Size: 6);
2343	case DK_QWORD:
2344	case DK_SQWORD:
2345	case DK_DQ:
2346	return parseDirectiveValue(IDVal, Size: 8);
2347	case DK_REAL4:
2348	return parseDirectiveRealValue(IDVal, Semantics: APFloat::IEEEsingle(), Size: 4);
2349	case DK_REAL8:
2350	return parseDirectiveRealValue(IDVal, Semantics: APFloat::IEEEdouble(), Size: 8);
2351	case DK_REAL10:
2352	return parseDirectiveRealValue(IDVal, Semantics: APFloat::x87DoubleExtended(), Size: 10);
2353	case DK_STRUCT:
2354	case DK_UNION:
2355	return parseDirectiveNestedStruct(Directive: IDVal, DirKind);
2356	case DK_ENDS:
2357	return parseDirectiveNestedEnds();
2358	case DK_ALIGN:
2359	return parseDirectiveAlign();
2360	case DK_EVEN:
2361	return parseDirectiveEven();
2362	case DK_ORG:
2363	return parseDirectiveOrg();
2364	case DK_EXTERN:
2365	return parseDirectiveExtern();
2366	case DK_PUBLIC:
2367	return parseDirectiveSymbolAttribute(Attr: MCSA_Global);
2368	case DK_COMM:
2369	return parseDirectiveComm(/*IsLocal=*/false);
2370	case DK_COMMENT:
2371	return parseDirectiveComment(DirectiveLoc: IDLoc);
2372	case DK_INCLUDE:
2373	return parseDirectiveInclude();
2374	case DK_REPEAT:
2375	return parseDirectiveRepeat(DirectiveLoc: IDLoc, Directive: IDVal);
2376	case DK_WHILE:
2377	return parseDirectiveWhile(DirectiveLoc: IDLoc);
2378	case DK_FOR:
2379	return parseDirectiveFor(DirectiveLoc: IDLoc, Directive: IDVal);
2380	case DK_FORC:
2381	return parseDirectiveForc(DirectiveLoc: IDLoc, Directive: IDVal);
2382	case DK_FILE:
2383	return parseDirectiveFile(DirectiveLoc: IDLoc);
2384	case DK_LINE:
2385	return parseDirectiveLine();
2386	case DK_LOC:
2387	return parseDirectiveLoc();
2388	case DK_STABS:
2389	return parseDirectiveStabs();
2390	case DK_CV_FILE:
2391	return parseDirectiveCVFile();
2392	case DK_CV_FUNC_ID:
2393	return parseDirectiveCVFuncId();
2394	case DK_CV_INLINE_SITE_ID:
2395	return parseDirectiveCVInlineSiteId();
2396	case DK_CV_LOC:
2397	return parseDirectiveCVLoc();
2398	case DK_CV_LINETABLE:
2399	return parseDirectiveCVLinetable();
2400	case DK_CV_INLINE_LINETABLE:
2401	return parseDirectiveCVInlineLinetable();
2402	case DK_CV_DEF_RANGE:
2403	return parseDirectiveCVDefRange();
2404	case DK_CV_STRING:
2405	return parseDirectiveCVString();
2406	case DK_CV_STRINGTABLE:
2407	return parseDirectiveCVStringTable();
2408	case DK_CV_FILECHECKSUMS:
2409	return parseDirectiveCVFileChecksums();
2410	case DK_CV_FILECHECKSUM_OFFSET:
2411	return parseDirectiveCVFileChecksumOffset();
2412	case DK_CV_FPO_DATA:
2413	return parseDirectiveCVFPOData();
2414	case DK_CFI_SECTIONS:
2415	return parseDirectiveCFISections();
2416	case DK_CFI_STARTPROC:
2417	return parseDirectiveCFIStartProc();
2418	case DK_CFI_ENDPROC:
2419	return parseDirectiveCFIEndProc();
2420	case DK_CFI_DEF_CFA:
2421	return parseDirectiveCFIDefCfa(DirectiveLoc: IDLoc);
2422	case DK_CFI_DEF_CFA_OFFSET:
2423	return parseDirectiveCFIDefCfaOffset(DirectiveLoc: IDLoc);
2424	case DK_CFI_ADJUST_CFA_OFFSET:
2425	return parseDirectiveCFIAdjustCfaOffset(DirectiveLoc: IDLoc);
2426	case DK_CFI_DEF_CFA_REGISTER:
2427	return parseDirectiveCFIDefCfaRegister(DirectiveLoc: IDLoc);
2428	case DK_CFI_OFFSET:
2429	return parseDirectiveCFIOffset(DirectiveLoc: IDLoc);
2430	case DK_CFI_REL_OFFSET:
2431	return parseDirectiveCFIRelOffset(DirectiveLoc: IDLoc);
2432	case DK_CFI_PERSONALITY:
2433	return parseDirectiveCFIPersonalityOrLsda(IsPersonality: true);
2434	case DK_CFI_LSDA:
2435	return parseDirectiveCFIPersonalityOrLsda(IsPersonality: false);
2436	case DK_CFI_REMEMBER_STATE:
2437	return parseDirectiveCFIRememberState(DirectiveLoc: IDLoc);
2438	case DK_CFI_RESTORE_STATE:
2439	return parseDirectiveCFIRestoreState(DirectiveLoc: IDLoc);
2440	case DK_CFI_SAME_VALUE:
2441	return parseDirectiveCFISameValue(DirectiveLoc: IDLoc);
2442	case DK_CFI_RESTORE:
2443	return parseDirectiveCFIRestore(DirectiveLoc: IDLoc);
2444	case DK_CFI_ESCAPE:
2445	return parseDirectiveCFIEscape(DirectiveLoc: IDLoc);
2446	case DK_CFI_RETURN_COLUMN:
2447	return parseDirectiveCFIReturnColumn(DirectiveLoc: IDLoc);
2448	case DK_CFI_SIGNAL_FRAME:
2449	return parseDirectiveCFISignalFrame();
2450	case DK_CFI_UNDEFINED:
2451	return parseDirectiveCFIUndefined(DirectiveLoc: IDLoc);
2452	case DK_CFI_REGISTER:
2453	return parseDirectiveCFIRegister(DirectiveLoc: IDLoc);
2454	case DK_CFI_WINDOW_SAVE:
2455	return parseDirectiveCFIWindowSave(DirectiveLoc: IDLoc);
2456	case DK_EXITM:
2457	Info.ExitValue = "";
2458	return parseDirectiveExitMacro(DirectiveLoc: IDLoc, Directive: IDVal, Value&: *Info.ExitValue);
2459	case DK_ENDM:
2460	Info.ExitValue = "";
2461	return parseDirectiveEndMacro(Directive: IDVal);
2462	case DK_PURGE:
2463	return parseDirectivePurgeMacro(DirectiveLoc: IDLoc);
2464	case DK_END:
2465	return parseDirectiveEnd(DirectiveLoc: IDLoc);
2466	case DK_ERR:
2467	return parseDirectiveError(DirectiveLoc: IDLoc);
2468	case DK_ERRB:
2469	return parseDirectiveErrorIfb(DirectiveLoc: IDLoc, ExpectBlank: true);
2470	case DK_ERRNB:
2471	return parseDirectiveErrorIfb(DirectiveLoc: IDLoc, ExpectBlank: false);
2472	case DK_ERRDEF:
2473	return parseDirectiveErrorIfdef(DirectiveLoc: IDLoc, ExpectDefined: true);
2474	case DK_ERRNDEF:
2475	return parseDirectiveErrorIfdef(DirectiveLoc: IDLoc, ExpectDefined: false);
2476	case DK_ERRDIF:
2477	return parseDirectiveErrorIfidn(DirectiveLoc: IDLoc, /*ExpectEqual=*/false,
2478	/*CaseInsensitive=*/false);
2479	case DK_ERRDIFI:
2480	return parseDirectiveErrorIfidn(DirectiveLoc: IDLoc, /*ExpectEqual=*/false,
2481	/*CaseInsensitive=*/true);
2482	case DK_ERRIDN:
2483	return parseDirectiveErrorIfidn(DirectiveLoc: IDLoc, /*ExpectEqual=*/true,
2484	/*CaseInsensitive=*/false);
2485	case DK_ERRIDNI:
2486	return parseDirectiveErrorIfidn(DirectiveLoc: IDLoc, /*ExpectEqual=*/true,
2487	/*CaseInsensitive=*/true);
2488	case DK_ERRE:
2489	return parseDirectiveErrorIfe(DirectiveLoc: IDLoc, ExpectZero: true);
2490	case DK_ERRNZ:
2491	return parseDirectiveErrorIfe(DirectiveLoc: IDLoc, ExpectZero: false);
2492	case DK_RADIX:
2493	return parseDirectiveRadix(DirectiveLoc: IDLoc);
2494	case DK_ECHO:
2495	return parseDirectiveEcho(DirectiveLoc: IDLoc);
2496	}
2497
2498	return Error(L: IDLoc, Msg: "unknown directive");
2499	}
2500
2501	// We also check if this is allocating memory with user-defined type.
2502	auto IDIt = Structs.find(Key: IDVal.lower());
2503	if (IDIt != Structs.end())
2504	return parseDirectiveStructValue(/*Structure=*/IDIt->getValue(), Directive: IDVal,
2505	DirLoc: IDLoc);
2506
2507	// Non-conditional Microsoft directives sometimes follow their first argument.
2508	const AsmToken nextTok = getTok();
2509	const StringRef nextVal = nextTok.getString();
2510	const SMLoc nextLoc = nextTok.getLoc();
2511
2512	const AsmToken afterNextTok = peekTok();
2513
2514	// There are several entities interested in parsing infix directives:
2515	//
2516	// 1. Asm parser extensions. For example, platform-specific parsers
2517	// (like the ELF parser) register themselves as extensions.
2518	// 2. The generic directive parser implemented by this class. These are
2519	// all the directives that behave in a target and platform independent
2520	// manner, or at least have a default behavior that's shared between
2521	// all targets and platforms.
2522
2523	getTargetParser().flushPendingInstructions(Out&: getStreamer());
2524
2525	// Special-case handling of structure-end directives at higher priority, since
2526	// ENDS is overloaded as a segment-end directive.
2527	if (nextVal.equals_insensitive(RHS: "ends") && StructInProgress.size() == 1) {
2528	Lex();
2529	return parseDirectiveEnds(Name: IDVal, NameLoc: IDLoc);
2530	}
2531
2532	// First, check the extension directive map to see if any extension has
2533	// registered itself to parse this directive.
2534	std::pair<MCAsmParserExtension *, DirectiveHandler> Handler =
2535	ExtensionDirectiveMap.lookup(Key: nextVal.lower());
2536	if (Handler.first) {
2537	Lex();
2538	Lexer.UnLex(Token: ID);
2539	return (*Handler.second)(Handler.first, nextVal, nextLoc);
2540	}
2541
2542	// If no one else is interested in this directive, it must be
2543	// generic and familiar to this class.
2544	DirKindIt = DirectiveKindMap.find(Key: nextVal.lower());
2545	DirKind = (DirKindIt == DirectiveKindMap.end())
2546	? DK_NO_DIRECTIVE
2547	: DirKindIt->getValue();
2548	switch (DirKind) {
2549	default:
2550	break;
2551	case DK_ASSIGN:
2552	case DK_EQU:
2553	case DK_TEXTEQU:
2554	Lex();
2555	return parseDirectiveEquate(IDVal: nextVal, Name: IDVal, DirKind, NameLoc: IDLoc);
2556	case DK_BYTE:
2557	if (afterNextTok.is(K: AsmToken::Identifier) &&
2558	afterNextTok.getString().equals_insensitive(RHS: "ptr")) {
2559	// Size directive; part of an instruction.
2560	break;
2561	}
2562	[[fallthrough]];
2563	case DK_SBYTE:
2564	case DK_DB:
2565	Lex();
2566	return parseDirectiveNamedValue(TypeName: nextVal, Size: 1, Name: IDVal, NameLoc: IDLoc);
2567	case DK_WORD:
2568	if (afterNextTok.is(K: AsmToken::Identifier) &&
2569	afterNextTok.getString().equals_insensitive(RHS: "ptr")) {
2570	// Size directive; part of an instruction.
2571	break;
2572	}
2573	[[fallthrough]];
2574	case DK_SWORD:
2575	case DK_DW:
2576	Lex();
2577	return parseDirectiveNamedValue(TypeName: nextVal, Size: 2, Name: IDVal, NameLoc: IDLoc);
2578	case DK_DWORD:
2579	if (afterNextTok.is(K: AsmToken::Identifier) &&
2580	afterNextTok.getString().equals_insensitive(RHS: "ptr")) {
2581	// Size directive; part of an instruction.
2582	break;
2583	}
2584	[[fallthrough]];
2585	case DK_SDWORD:
2586	case DK_DD:
2587	Lex();
2588	return parseDirectiveNamedValue(TypeName: nextVal, Size: 4, Name: IDVal, NameLoc: IDLoc);
2589	case DK_FWORD:
2590	if (afterNextTok.is(K: AsmToken::Identifier) &&
2591	afterNextTok.getString().equals_insensitive(RHS: "ptr")) {
2592	// Size directive; part of an instruction.
2593	break;
2594	}
2595	[[fallthrough]];
2596	case DK_DF:
2597	Lex();
2598	return parseDirectiveNamedValue(TypeName: nextVal, Size: 6, Name: IDVal, NameLoc: IDLoc);
2599	case DK_QWORD:
2600	if (afterNextTok.is(K: AsmToken::Identifier) &&
2601	afterNextTok.getString().equals_insensitive(RHS: "ptr")) {
2602	// Size directive; part of an instruction.
2603	break;
2604	}
2605	[[fallthrough]];
2606	case DK_SQWORD:
2607	case DK_DQ:
2608	Lex();
2609	return parseDirectiveNamedValue(TypeName: nextVal, Size: 8, Name: IDVal, NameLoc: IDLoc);
2610	case DK_REAL4:
2611	Lex();
2612	return parseDirectiveNamedRealValue(TypeName: nextVal, Semantics: APFloat::IEEEsingle(), Size: 4,
2613	Name: IDVal, NameLoc: IDLoc);
2614	case DK_REAL8:
2615	Lex();
2616	return parseDirectiveNamedRealValue(TypeName: nextVal, Semantics: APFloat::IEEEdouble(), Size: 8,
2617	Name: IDVal, NameLoc: IDLoc);
2618	case DK_REAL10:
2619	Lex();
2620	return parseDirectiveNamedRealValue(TypeName: nextVal, Semantics: APFloat::x87DoubleExtended(),
2621	Size: 10, Name: IDVal, NameLoc: IDLoc);
2622	case DK_STRUCT:
2623	case DK_UNION:
2624	Lex();
2625	return parseDirectiveStruct(Directive: nextVal, DirKind, Name: IDVal, NameLoc: IDLoc);
2626	case DK_ENDS:
2627	Lex();
2628	return parseDirectiveEnds(Name: IDVal, NameLoc: IDLoc);
2629	case DK_MACRO:
2630	Lex();
2631	return parseDirectiveMacro(Name: IDVal, NameLoc: IDLoc);
2632	}
2633
2634	// Finally, we check if this is allocating a variable with user-defined type.
2635	auto NextIt = Structs.find(Key: nextVal.lower());
2636	if (NextIt != Structs.end()) {
2637	Lex();
2638	return parseDirectiveNamedStructValue(/*Structure=*/NextIt->getValue(),
2639	Directive: nextVal, DirLoc: nextLoc, Name: IDVal);
2640	}
2641
2642	// __asm _emit or __asm __emit
2643	if (ParsingMSInlineAsm && (IDVal == "_emit" || IDVal == "__emit" ||
2644	IDVal == "_EMIT" || IDVal == "__EMIT"))
2645	return parseDirectiveMSEmit(DirectiveLoc: IDLoc, Info, Len: IDVal.size());
2646
2647	// __asm align
2648	if (ParsingMSInlineAsm && (IDVal == "align" || IDVal == "ALIGN"))
2649	return parseDirectiveMSAlign(DirectiveLoc: IDLoc, Info);
2650
2651	if (ParsingMSInlineAsm && (IDVal == "even" || IDVal == "EVEN"))
2652	Info.AsmRewrites->emplace_back(Args: AOK_EVEN, Args&: IDLoc, Args: 4);
2653	if (checkForValidSection())
2654	return true;
2655
2656	// Canonicalize the opcode to lower case.
2657	std::string OpcodeStr = IDVal.lower();
2658	ParseInstructionInfo IInfo(Info.AsmRewrites);
2659	bool ParseHadError = getTargetParser().ParseInstruction(Info&: IInfo, Name: OpcodeStr, Token: ID,
2660	Operands&: Info.ParsedOperands);
2661	Info.ParseError = ParseHadError;
2662
2663	// Dump the parsed representation, if requested.
2664	if (getShowParsedOperands()) {
2665	SmallString<256> Str;
2666	raw_svector_ostream OS(Str);
2667	OS << "parsed instruction: [";
2668	for (unsigned i = 0; i != Info.ParsedOperands.size(); ++i) {
2669	if (i != 0)
2670	OS << ", ";
2671	Info.ParsedOperands[i]->print(OS);
2672	}
2673	OS << "]";
2674
2675	printMessage(Loc: IDLoc, Kind: SourceMgr::DK_Note, Msg: OS.str());
2676	}
2677
2678	// Fail even if ParseInstruction erroneously returns false.
2679	if (hasPendingError() || ParseHadError)
2680	return true;
2681
2682	// If we are generating dwarf for the current section then generate a .loc
2683	// directive for the instruction.
2684	if (!ParseHadError && enabledGenDwarfForAssembly() &&
2685	getContext().getGenDwarfSectionSyms().count(
2686	key: getStreamer().getCurrentSectionOnly())) {
2687	unsigned Line;
2688	if (ActiveMacros.empty())
2689	Line = SrcMgr.FindLineNumber(Loc: IDLoc, BufferID: CurBuffer);
2690	else
2691	Line = SrcMgr.FindLineNumber(Loc: ActiveMacros.front()->InstantiationLoc,
2692	BufferID: ActiveMacros.front()->ExitBuffer);
2693
2694	// If we previously parsed a cpp hash file line comment then make sure the
2695	// current Dwarf File is for the CppHashFilename if not then emit the
2696	// Dwarf File table for it and adjust the line number for the .loc.
2697	if (!CppHashInfo.Filename.empty()) {
2698	unsigned FileNumber = getStreamer().emitDwarfFileDirective(
2699	FileNo: 0, Directory: StringRef(), Filename: CppHashInfo.Filename);
2700	getContext().setGenDwarfFileNumber(FileNumber);
2701
2702	unsigned CppHashLocLineNo =
2703	SrcMgr.FindLineNumber(Loc: CppHashInfo.Loc, BufferID: CppHashInfo.Buf);
2704	Line = CppHashInfo.LineNumber - 1 + (Line - CppHashLocLineNo);
2705	}
2706
2707	getStreamer().emitDwarfLocDirective(
2708	FileNo: getContext().getGenDwarfFileNumber(), Line, Column: 0,
2709	DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0, Isa: 0, Discriminator: 0,
2710	FileName: StringRef());
2711	}
2712
2713	// If parsing succeeded, match the instruction.
2714	if (!ParseHadError) {
2715	uint64_t ErrorInfo;
2716	if (getTargetParser().MatchAndEmitInstruction(
2717	IDLoc, Opcode&: Info.Opcode, Operands&: Info.ParsedOperands, Out, ErrorInfo,
2718	MatchingInlineAsm: getTargetParser().isParsingMSInlineAsm()))
2719	return true;
2720	}
2721	return false;
2722	}
2723
2724	// Parse and erase curly braces marking block start/end.
2725	bool MasmParser::parseCurlyBlockScope(
2726	SmallVectorImpl<AsmRewrite> &AsmStrRewrites) {
2727	// Identify curly brace marking block start/end.
2728	if (Lexer.isNot(K: AsmToken::LCurly) && Lexer.isNot(K: AsmToken::RCurly))
2729	return false;
2730
2731	SMLoc StartLoc = Lexer.getLoc();
2732	Lex(); // Eat the brace.
2733	if (Lexer.is(K: AsmToken::EndOfStatement))
2734	Lex(); // Eat EndOfStatement following the brace.
2735
2736	// Erase the block start/end brace from the output asm string.
2737	AsmStrRewrites.emplace_back(Args: AOK_Skip, Args&: StartLoc, Args: Lexer.getLoc().getPointer() -
2738	StartLoc.getPointer());
2739	return true;
2740	}
2741
2742	/// parseCppHashLineFilenameComment as this:
2743	/// ::= # number "filename"
2744	bool MasmParser::parseCppHashLineFilenameComment(SMLoc L) {
2745	Lex(); // Eat the hash token.
2746	// Lexer only ever emits HashDirective if it fully formed if it's
2747	// done the checking already so this is an internal error.
2748	assert(getTok().is(AsmToken::Integer) &&
2749	"Lexing Cpp line comment: Expected Integer");
2750	int64_t LineNumber = getTok().getIntVal();
2751	Lex();
2752	assert(getTok().is(AsmToken::String) &&
2753	"Lexing Cpp line comment: Expected String");
2754	StringRef Filename = getTok().getString();
2755	Lex();
2756
2757	// Get rid of the enclosing quotes.
2758	Filename = Filename.substr(Start: 1, N: Filename.size() - 2);
2759
2760	// Save the SMLoc, Filename and LineNumber for later use by diagnostics
2761	// and possibly DWARF file info.
2762	CppHashInfo.Loc = L;
2763	CppHashInfo.Filename = Filename;
2764	CppHashInfo.LineNumber = LineNumber;
2765	CppHashInfo.Buf = CurBuffer;
2766	if (FirstCppHashFilename.empty())
2767	FirstCppHashFilename = Filename;
2768	return false;
2769	}
2770
2771	/// will use the last parsed cpp hash line filename comment
2772	/// for the Filename and LineNo if any in the diagnostic.
2773	void MasmParser::DiagHandler(const SMDiagnostic &Diag, void *Context) {
2774	const MasmParser *Parser = static_cast<const MasmParser *>(Context);
2775	raw_ostream &OS = errs();
2776
2777	const SourceMgr &DiagSrcMgr = *Diag.getSourceMgr();
2778	SMLoc DiagLoc = Diag.getLoc();
2779	unsigned DiagBuf = DiagSrcMgr.FindBufferContainingLoc(Loc: DiagLoc);
2780	unsigned CppHashBuf =
2781	Parser->SrcMgr.FindBufferContainingLoc(Loc: Parser->CppHashInfo.Loc);
2782
2783	// Like SourceMgr::printMessage() we need to print the include stack if any
2784	// before printing the message.
2785	unsigned DiagCurBuffer = DiagSrcMgr.FindBufferContainingLoc(Loc: DiagLoc);
2786	if (!Parser->SavedDiagHandler && DiagCurBuffer &&
2787	DiagCurBuffer != DiagSrcMgr.getMainFileID()) {
2788	SMLoc ParentIncludeLoc = DiagSrcMgr.getParentIncludeLoc(i: DiagCurBuffer);
2789	DiagSrcMgr.PrintIncludeStack(IncludeLoc: ParentIncludeLoc, OS);
2790	}
2791
2792	// If we have not parsed a cpp hash line filename comment or the source
2793	// manager changed or buffer changed (like in a nested include) then just
2794	// print the normal diagnostic using its Filename and LineNo.
2795	if (!Parser->CppHashInfo.LineNumber || &DiagSrcMgr != &Parser->SrcMgr ||
2796	DiagBuf != CppHashBuf) {
2797	if (Parser->SavedDiagHandler)
2798	Parser->SavedDiagHandler(Diag, Parser->SavedDiagContext);
2799	else
2800	Diag.print(ProgName: nullptr, S&: OS);
2801	return;
2802	}
2803
2804	// Use the CppHashFilename and calculate a line number based on the
2805	// CppHashInfo.Loc and CppHashInfo.LineNumber relative to this Diag's SMLoc
2806	// for the diagnostic.
2807	const std::string &Filename = std::string(Parser->CppHashInfo.Filename);
2808
2809	int DiagLocLineNo = DiagSrcMgr.FindLineNumber(Loc: DiagLoc, BufferID: DiagBuf);
2810	int CppHashLocLineNo =
2811	Parser->SrcMgr.FindLineNumber(Loc: Parser->CppHashInfo.Loc, BufferID: CppHashBuf);
2812	int LineNo =
2813	Parser->CppHashInfo.LineNumber - 1 + (DiagLocLineNo - CppHashLocLineNo);
2814
2815	SMDiagnostic NewDiag(*Diag.getSourceMgr(), Diag.getLoc(), Filename, LineNo,
2816	Diag.getColumnNo(), Diag.getKind(), Diag.getMessage(),
2817	Diag.getLineContents(), Diag.getRanges());
2818
2819	if (Parser->SavedDiagHandler)
2820	Parser->SavedDiagHandler(NewDiag, Parser->SavedDiagContext);
2821	else
2822	NewDiag.print(ProgName: nullptr, S&: OS);
2823	}
2824
2825	// This is similar to the IsIdentifierChar function in AsmLexer.cpp, but does
2826	// not accept '.'.
2827	static bool isMacroParameterChar(char C) {
2828	return isAlnum(C) || C == '_' || C == '$' || C == '@' || C == '?';
2829	}
2830
2831	bool MasmParser::expandMacro(raw_svector_ostream &OS, StringRef Body,
2832	ArrayRef<MCAsmMacroParameter> Parameters,
2833	ArrayRef<MCAsmMacroArgument> A,
2834	const std::vector<std::string> &Locals, SMLoc L) {
2835	unsigned NParameters = Parameters.size();
2836	if (NParameters != A.size())
2837	return Error(L, Msg: "Wrong number of arguments");
2838	StringMap<std::string> LocalSymbols;
2839	std::string Name;
2840	Name.reserve(res: 6);
2841	for (StringRef Local : Locals) {
2842	raw_string_ostream LocalName(Name);
2843	LocalName << "??"
2844	<< format_hex_no_prefix(N: LocalCounter++, Width: 4, /*Upper=*/true);
2845	LocalSymbols.insert(KV: {Local, LocalName.str()});
2846	Name.clear();
2847	}
2848
2849	std::optional<char> CurrentQuote;
2850	while (!Body.empty()) {
2851	// Scan for the next substitution.
2852	std::size_t End = Body.size(), Pos = 0;
2853	std::size_t IdentifierPos = End;
2854	for (; Pos != End; ++Pos) {
2855	// Find the next possible macro parameter, including preceding a '&'
2856	// inside quotes.
2857	if (Body[Pos] == '&')
2858	break;
2859	if (isMacroParameterChar(C: Body[Pos])) {
2860	if (!CurrentQuote)
2861	break;
2862	if (IdentifierPos == End)
2863	IdentifierPos = Pos;
2864	} else {
2865	IdentifierPos = End;
2866	}
2867
2868	// Track quotation status
2869	if (!CurrentQuote) {
2870	if (Body[Pos] == '\'' || Body[Pos] == '"')
2871	CurrentQuote = Body[Pos];
2872	} else if (Body[Pos] == CurrentQuote) {
2873	if (Pos + 1 != End && Body[Pos + 1] == CurrentQuote) {
2874	// Escaped quote, and quotes aren't identifier chars; skip
2875	++Pos;
2876	continue;
2877	} else {
2878	CurrentQuote.reset();
2879	}
2880	}
2881	}
2882	if (IdentifierPos != End) {
2883	// We've recognized an identifier before an apostrophe inside quotes;
2884	// check once to see if we can expand it.
2885	Pos = IdentifierPos;
2886	IdentifierPos = End;
2887	}
2888
2889	// Add the prefix.
2890	OS << Body.slice(Start: 0, End: Pos);
2891
2892	// Check if we reached the end.
2893	if (Pos == End)
2894	break;
2895
2896	unsigned I = Pos;
2897	bool InitialAmpersand = (Body[I] == '&');
2898	if (InitialAmpersand) {
2899	++I;
2900	++Pos;
2901	}
2902	while (I < End && isMacroParameterChar(C: Body[I]))
2903	++I;
2904
2905	const char *Begin = Body.data() + Pos;
2906	StringRef Argument(Begin, I - Pos);
2907	const std::string ArgumentLower = Argument.lower();
2908	unsigned Index = 0;
2909
2910	for (; Index < NParameters; ++Index)
2911	if (Parameters[Index].Name.equals_insensitive(RHS: ArgumentLower))
2912	break;
2913
2914	if (Index == NParameters) {
2915	if (InitialAmpersand)
2916	OS << '&';
2917	auto it = LocalSymbols.find(Key: ArgumentLower);
2918	if (it != LocalSymbols.end())
2919	OS << it->second;
2920	else
2921	OS << Argument;
2922	Pos = I;
2923	} else {
2924	for (const AsmToken &Token : A[Index]) {
2925	// In MASM, you can write '%expr'.
2926	// The prefix '%' evaluates the expression 'expr'
2927	// and uses the result as a string (e.g. replace %(1+2) with the
2928	// string "3").
2929	// Here, we identify the integer token which is the result of the
2930	// absolute expression evaluation and replace it with its string
2931	// representation.
2932	if (Token.getString().front() == '%' && Token.is(K: AsmToken::Integer))
2933	// Emit an integer value to the buffer.
2934	OS << Token.getIntVal();
2935	else
2936	OS << Token.getString();
2937	}
2938
2939	Pos += Argument.size();
2940	if (Pos < End && Body[Pos] == '&') {
2941	++Pos;
2942	}
2943	}
2944	// Update the scan point.
2945	Body = Body.substr(Start: Pos);
2946	}
2947
2948	return false;
2949	}
2950
2951	static bool isOperator(AsmToken::TokenKind kind) {
2952	switch (kind) {
2953	default:
2954	return false;
2955	case AsmToken::Plus:
2956	case AsmToken::Minus:
2957	case AsmToken::Tilde:
2958	case AsmToken::Slash:
2959	case AsmToken::Star:
2960	case AsmToken::Dot:
2961	case AsmToken::Equal:
2962	case AsmToken::EqualEqual:
2963	case AsmToken::Pipe:
2964	case AsmToken::PipePipe:
2965	case AsmToken::Caret:
2966	case AsmToken::Amp:
2967	case AsmToken::AmpAmp:
2968	case AsmToken::Exclaim:
2969	case AsmToken::ExclaimEqual:
2970	case AsmToken::Less:
2971	case AsmToken::LessEqual:
2972	case AsmToken::LessLess:
2973	case AsmToken::LessGreater:
2974	case AsmToken::Greater:
2975	case AsmToken::GreaterEqual:
2976	case AsmToken::GreaterGreater:
2977	return true;
2978	}
2979	}
2980
2981	namespace {
2982
2983	class AsmLexerSkipSpaceRAII {
2984	public:
2985	AsmLexerSkipSpaceRAII(AsmLexer &Lexer, bool SkipSpace) : Lexer(Lexer) {
2986	Lexer.setSkipSpace(SkipSpace);
2987	}
2988
2989	~AsmLexerSkipSpaceRAII() {
2990	Lexer.setSkipSpace(true);
2991	}
2992
2993	private:
2994	AsmLexer &Lexer;
2995	};
2996
2997	} // end anonymous namespace
2998
2999	bool MasmParser::parseMacroArgument(const MCAsmMacroParameter *MP,
3000	MCAsmMacroArgument &MA,
3001	AsmToken::TokenKind EndTok) {
3002	if (MP && MP->Vararg) {
3003	if (Lexer.isNot(K: EndTok)) {
3004	SmallVector<StringRef, 1> Str = parseStringRefsTo(EndTok);
3005	for (StringRef S : Str) {
3006	MA.emplace_back(args: AsmToken::String, args&: S);
3007	}
3008	}
3009	return false;
3010	}
3011
3012	SMLoc StrLoc = Lexer.getLoc(), EndLoc;
3013	if (Lexer.is(K: AsmToken::Less) && isAngleBracketString(StrLoc, EndLoc)) {
3014	const char *StrChar = StrLoc.getPointer() + 1;
3015	const char *EndChar = EndLoc.getPointer() - 1;
3016	jumpToLoc(Loc: EndLoc, InBuffer: CurBuffer, EndStatementAtEOF: EndStatementAtEOFStack.back());
3017	/// Eat from '<' to '>'.
3018	Lex();
3019	MA.emplace_back(args: AsmToken::String, args: StringRef(StrChar, EndChar - StrChar));
3020	return false;
3021	}
3022
3023	unsigned ParenLevel = 0;
3024
3025	// Darwin doesn't use spaces to delmit arguments.
3026	AsmLexerSkipSpaceRAII ScopedSkipSpace(Lexer, IsDarwin);
3027
3028	bool SpaceEaten;
3029
3030	while (true) {
3031	SpaceEaten = false;
3032	if (Lexer.is(K: AsmToken::Eof) || Lexer.is(K: AsmToken::Equal))
3033	return TokError(Msg: "unexpected token");
3034
3035	if (ParenLevel == 0) {
3036	if (Lexer.is(K: AsmToken::Comma))
3037	break;
3038
3039	if (Lexer.is(K: AsmToken::Space)) {
3040	SpaceEaten = true;
3041	Lex(); // Eat spaces.
3042	}
3043
3044	// Spaces can delimit parameters, but could also be part an expression.
3045	// If the token after a space is an operator, add the token and the next
3046	// one into this argument
3047	if (!IsDarwin) {
3048	if (isOperator(kind: Lexer.getKind()) && Lexer.isNot(K: EndTok)) {
3049	MA.push_back(x: getTok());
3050	Lex();
3051
3052	// Whitespace after an operator can be ignored.
3053	if (Lexer.is(K: AsmToken::Space))
3054	Lex();
3055
3056	continue;
3057	}
3058	}
3059	if (SpaceEaten)
3060	break;
3061	}
3062
3063	// handleMacroEntry relies on not advancing the lexer here
3064	// to be able to fill in the remaining default parameter values
3065	if (Lexer.is(K: EndTok) && (EndTok != AsmToken::RParen || ParenLevel == 0))
3066	break;
3067
3068	// Adjust the current parentheses level.
3069	if (Lexer.is(K: AsmToken::LParen))
3070	++ParenLevel;
3071	else if (Lexer.is(K: AsmToken::RParen) && ParenLevel)
3072	--ParenLevel;
3073
3074	// Append the token to the current argument list.
3075	MA.push_back(x: getTok());
3076	Lex();
3077	}
3078
3079	if (ParenLevel != 0)
3080	return TokError(Msg: "unbalanced parentheses in argument");
3081
3082	if (MA.empty() && MP) {
3083	if (MP->Required) {
3084	return TokError(Msg: "missing value for required parameter '" + MP->Name +
3085	"'");
3086	} else {
3087	MA = MP->Value;
3088	}
3089	}
3090	return false;
3091	}
3092
3093	// Parse the macro instantiation arguments.
3094	bool MasmParser::parseMacroArguments(const MCAsmMacro *M,
3095	MCAsmMacroArguments &A,
3096	AsmToken::TokenKind EndTok) {
3097	const unsigned NParameters = M ? M->Parameters.size() : 0;
3098	bool NamedParametersFound = false;
3099	SmallVector<SMLoc, 4> FALocs;
3100
3101	A.resize(new_size: NParameters);
3102	FALocs.resize(N: NParameters);
3103
3104	// Parse two kinds of macro invocations:
3105	// - macros defined without any parameters accept an arbitrary number of them
3106	// - macros defined with parameters accept at most that many of them
3107	for (unsigned Parameter = 0; !NParameters || Parameter < NParameters;
3108	++Parameter) {
3109	SMLoc IDLoc = Lexer.getLoc();
3110	MCAsmMacroParameter FA;
3111
3112	if (Lexer.is(K: AsmToken::Identifier) && peekTok().is(K: AsmToken::Equal)) {
3113	if (parseIdentifier(Res&: FA.Name))
3114	return Error(L: IDLoc, Msg: "invalid argument identifier for formal argument");
3115
3116	if (Lexer.isNot(K: AsmToken::Equal))
3117	return TokError(Msg: "expected '=' after formal parameter identifier");
3118
3119	Lex();
3120
3121	NamedParametersFound = true;
3122	}
3123
3124	if (NamedParametersFound && FA.Name.empty())
3125	return Error(L: IDLoc, Msg: "cannot mix positional and keyword arguments");
3126
3127	unsigned PI = Parameter;
3128	if (!FA.Name.empty()) {
3129	assert(M && "expected macro to be defined");
3130	unsigned FAI = 0;
3131	for (FAI = 0; FAI < NParameters; ++FAI)
3132	if (M->Parameters[FAI].Name == FA.Name)
3133	break;
3134
3135	if (FAI >= NParameters) {
3136	return Error(L: IDLoc, Msg: "parameter named '" + FA.Name +
3137	"' does not exist for macro '" + M->Name + "'");
3138	}
3139	PI = FAI;
3140	}
3141	const MCAsmMacroParameter *MP = nullptr;
3142	if (M && PI < NParameters)
3143	MP = &M->Parameters[PI];
3144
3145	SMLoc StrLoc = Lexer.getLoc();
3146	SMLoc EndLoc;
3147	if (Lexer.is(K: AsmToken::Percent)) {
3148	const MCExpr *AbsoluteExp;
3149	int64_t Value;
3150	/// Eat '%'.
3151	Lex();
3152	if (parseExpression(Res&: AbsoluteExp, EndLoc))
3153	return false;
3154	if (!AbsoluteExp->evaluateAsAbsolute(Res&: Value,
3155	Asm: getStreamer().getAssemblerPtr()))
3156	return Error(L: StrLoc, Msg: "expected absolute expression");
3157	const char *StrChar = StrLoc.getPointer();
3158	const char *EndChar = EndLoc.getPointer();
3159	AsmToken newToken(AsmToken::Integer,
3160	StringRef(StrChar, EndChar - StrChar), Value);
3161	FA.Value.push_back(x: newToken);
3162	} else if (parseMacroArgument(MP, MA&: FA.Value, EndTok)) {
3163	if (M)
3164	return addErrorSuffix(Suffix: " in '" + M->Name + "' macro");
3165	else
3166	return true;
3167	}
3168
3169	if (!FA.Value.empty()) {
3170	if (A.size() <= PI)
3171	A.resize(new_size: PI + 1);
3172	A[PI] = FA.Value;
3173
3174	if (FALocs.size() <= PI)
3175	FALocs.resize(N: PI + 1);
3176
3177	FALocs[PI] = Lexer.getLoc();
3178	}
3179
3180	// At the end of the statement, fill in remaining arguments that have
3181	// default values. If there aren't any, then the next argument is
3182	// required but missing
3183	if (Lexer.is(K: EndTok)) {
3184	bool Failure = false;
3185	for (unsigned FAI = 0; FAI < NParameters; ++FAI) {
3186	if (A[FAI].empty()) {
3187	if (M->Parameters[FAI].Required) {
3188	Error(L: FALocs[FAI].isValid() ? FALocs[FAI] : Lexer.getLoc(),
3189	Msg: "missing value for required parameter "
3190	"'" +
3191	M->Parameters[FAI].Name + "' in macro '" + M->Name + "'");
3192	Failure = true;
3193	}
3194
3195	if (!M->Parameters[FAI].Value.empty())
3196	A[FAI] = M->Parameters[FAI].Value;
3197	}
3198	}
3199	return Failure;
3200	}
3201
3202	if (Lexer.is(K: AsmToken::Comma))
3203	Lex();
3204	}
3205
3206	return TokError(Msg: "too many positional arguments");
3207	}
3208
3209	bool MasmParser::handleMacroEntry(const MCAsmMacro *M, SMLoc NameLoc,
3210	AsmToken::TokenKind ArgumentEndTok) {
3211	// Arbitrarily limit macro nesting depth (default matches 'as'). We can
3212	// eliminate this, although we should protect against infinite loops.
3213	unsigned MaxNestingDepth = AsmMacroMaxNestingDepth;
3214	if (ActiveMacros.size() == MaxNestingDepth) {
3215	std::ostringstream MaxNestingDepthError;
3216	MaxNestingDepthError << "macros cannot be nested more than "
3217	<< MaxNestingDepth << " levels deep."
3218	<< " Use -asm-macro-max-nesting-depth to increase "
3219	"this limit.";
3220	return TokError(Msg: MaxNestingDepthError.str());
3221	}
3222
3223	MCAsmMacroArguments A;
3224	if (parseMacroArguments(M, A, EndTok: ArgumentEndTok))
3225	return true;
3226
3227	// Macro instantiation is lexical, unfortunately. We construct a new buffer
3228	// to hold the macro body with substitutions.
3229	SmallString<256> Buf;
3230	StringRef Body = M->Body;
3231	raw_svector_ostream OS(Buf);
3232
3233	if (expandMacro(OS, Body, Parameters: M->Parameters, A, Locals: M->Locals, L: getTok().getLoc()))
3234	return true;
3235
3236	// We include the endm in the buffer as our cue to exit the macro
3237	// instantiation.
3238	OS << "endm\n";
3239
3240	std::unique_ptr<MemoryBuffer> Instantiation =
3241	MemoryBuffer::getMemBufferCopy(InputData: OS.str(), BufferName: "<instantiation>");
3242
3243	// Create the macro instantiation object and add to the current macro
3244	// instantiation stack.
3245	MacroInstantiation *MI = new MacroInstantiation{
3246	.InstantiationLoc: NameLoc, .ExitBuffer: CurBuffer, .ExitLoc: getTok().getLoc(), .CondStackDepth: TheCondStack.size()};
3247	ActiveMacros.push_back(x: MI);
3248
3249	++NumOfMacroInstantiations;
3250
3251	// Jump to the macro instantiation and prime the lexer.
3252	CurBuffer = SrcMgr.AddNewSourceBuffer(F: std::move(Instantiation), IncludeLoc: SMLoc());
3253	Lexer.setBuffer(Buf: SrcMgr.getMemoryBuffer(i: CurBuffer)->getBuffer());
3254	EndStatementAtEOFStack.push_back(Val: true);
3255	Lex();
3256
3257	return false;
3258	}
3259
3260	void MasmParser::handleMacroExit() {
3261	// Jump to the token we should return to, and consume it.
3262	EndStatementAtEOFStack.pop_back();
3263	jumpToLoc(Loc: ActiveMacros.back()->ExitLoc, InBuffer: ActiveMacros.back()->ExitBuffer,
3264	EndStatementAtEOF: EndStatementAtEOFStack.back());
3265	Lex();
3266
3267	// Pop the instantiation entry.
3268	delete ActiveMacros.back();
3269	ActiveMacros.pop_back();
3270	}
3271
3272	bool MasmParser::handleMacroInvocation(const MCAsmMacro *M, SMLoc NameLoc) {
3273	if (!M->IsFunction)
3274	return Error(L: NameLoc, Msg: "cannot invoke macro procedure as function");
3275
3276	if (parseToken(T: AsmToken::LParen, Msg: "invoking macro function '" + M->Name +
3277	"' requires arguments in parentheses") ||
3278	handleMacroEntry(M, NameLoc, ArgumentEndTok: AsmToken::RParen))
3279	return true;
3280
3281	// Parse all statements in the macro, retrieving the exit value when it ends.
3282	std::string ExitValue;
3283	SmallVector<AsmRewrite, 4> AsmStrRewrites;
3284	while (Lexer.isNot(K: AsmToken::Eof)) {
3285	ParseStatementInfo Info(&AsmStrRewrites);
3286	bool Parsed = parseStatement(Info, SI: nullptr);
3287
3288	if (!Parsed && Info.ExitValue) {
3289	ExitValue = std::move(*Info.ExitValue);
3290	break;
3291	}
3292
3293	// If we have a Lexer Error we are on an Error Token. Load in Lexer Error
3294	// for printing ErrMsg via Lex() only if no (presumably better) parser error
3295	// exists.
3296	if (Parsed && !hasPendingError() && Lexer.getTok().is(K: AsmToken::Error)) {
3297	Lex();
3298	}
3299
3300	// parseStatement returned true so may need to emit an error.
3301	printPendingErrors();
3302
3303	// Skipping to the next line if needed.
3304	if (Parsed && !getLexer().isAtStartOfStatement())
3305	eatToEndOfStatement();
3306	}
3307
3308	// Consume the right-parenthesis on the other side of the arguments.
3309	if (parseRParen())
3310	return true;
3311
3312	// Exit values may require lexing, unfortunately. We construct a new buffer to
3313	// hold the exit value.
3314	std::unique_ptr<MemoryBuffer> MacroValue =
3315	MemoryBuffer::getMemBufferCopy(InputData: ExitValue, BufferName: "<macro-value>");
3316
3317	// Jump from this location to the instantiated exit value, and prime the
3318	// lexer.
3319	CurBuffer = SrcMgr.AddNewSourceBuffer(F: std::move(MacroValue), IncludeLoc: Lexer.getLoc());
3320	Lexer.setBuffer(Buf: SrcMgr.getMemoryBuffer(i: CurBuffer)->getBuffer(), ptr: nullptr,
3321	/*EndStatementAtEOF=*/false);
3322	EndStatementAtEOFStack.push_back(Val: false);
3323	Lex();
3324
3325	return false;
3326	}
3327
3328	/// parseIdentifier:
3329	/// ::= identifier
3330	/// ::= string
3331	bool MasmParser::parseIdentifier(StringRef &Res,
3332	IdentifierPositionKind Position) {
3333	// The assembler has relaxed rules for accepting identifiers, in particular we
3334	// allow things like '.globl $foo' and '.def @feat.00', which would normally
3335	// be separate tokens. At this level, we have already lexed so we cannot
3336	// (currently) handle this as a context dependent token, instead we detect
3337	// adjacent tokens and return the combined identifier.
3338	if (Lexer.is(K: AsmToken::Dollar) || Lexer.is(K: AsmToken::At)) {
3339	SMLoc PrefixLoc = getLexer().getLoc();
3340
3341	// Consume the prefix character, and check for a following identifier.
3342
3343	AsmToken nextTok = peekTok(ShouldSkipSpace: false);
3344
3345	if (nextTok.isNot(K: AsmToken::Identifier))
3346	return true;
3347
3348	// We have a '$' or '@' followed by an identifier, make sure they are adjacent.
3349	if (PrefixLoc.getPointer() + 1 != nextTok.getLoc().getPointer())
3350	return true;
3351
3352	// eat $ or @
3353	Lexer.Lex(); // Lexer's Lex guarantees consecutive token.
3354	// Construct the joined identifier and consume the token.
3355	Res =
3356	StringRef(PrefixLoc.getPointer(), getTok().getIdentifier().size() + 1);
3357	Lex(); // Parser Lex to maintain invariants.
3358	return false;
3359	}
3360
3361	if (Lexer.isNot(K: AsmToken::Identifier) && Lexer.isNot(K: AsmToken::String))
3362	return true;
3363
3364	Res = getTok().getIdentifier();
3365
3366	// Consume the identifier token - but if parsing certain directives, avoid
3367	// lexical expansion of the next token.
3368	ExpandKind ExpandNextToken = ExpandMacros;
3369	if (Position == StartOfStatement &&
3370	StringSwitch<bool>(Res)
3371	.CaseLower(S: "echo", Value: true)
3372	.CasesLower(S0: "ifdef", S1: "ifndef", S2: "elseifdef", S3: "elseifndef", Value: true)
3373	.Default(Value: false)) {
3374	ExpandNextToken = DoNotExpandMacros;
3375	}
3376	Lex(ExpandNextToken);
3377
3378	return false;
3379	}
3380
3381	/// parseDirectiveEquate:
3382	/// ::= name "=" expression
3383	/// | name "equ" expression (not redefinable)
3384	/// | name "equ" text-list
3385	/// | name "textequ" text-list (redefinability unspecified)
3386	bool MasmParser::parseDirectiveEquate(StringRef IDVal, StringRef Name,
3387	DirectiveKind DirKind, SMLoc NameLoc) {
3388	auto BuiltinIt = BuiltinSymbolMap.find(Key: Name.lower());
3389	if (BuiltinIt != BuiltinSymbolMap.end())
3390	return Error(L: NameLoc, Msg: "cannot redefine a built-in symbol");
3391
3392	Variable &Var = Variables[Name.lower()];
3393	if (Var.Name.empty()) {
3394	Var.Name = Name;
3395	}
3396
3397	SMLoc StartLoc = Lexer.getLoc();
3398	if (DirKind == DK_EQU || DirKind == DK_TEXTEQU) {
3399	// "equ" and "textequ" both allow text expressions.
3400	std::string Value;
3401	std::string TextItem;
3402	if (!parseTextItem(Data&: TextItem)) {
3403	Value += TextItem;
3404
3405	// Accept a text-list, not just one text-item.
3406	auto parseItem = [&]() -> bool {
3407	if (parseTextItem(Data&: TextItem))
3408	return TokError(Msg: "expected text item");
3409	Value += TextItem;
3410	return false;
3411	};
3412	if (parseOptionalToken(T: AsmToken::Comma) && parseMany(parseOne: parseItem))
3413	return addErrorSuffix(Suffix: " in '" + Twine(IDVal) + "' directive");
3414
3415	if (!Var.IsText || Var.TextValue != Value) {
3416	switch (Var.Redefinable) {
3417	case Variable::NOT_REDEFINABLE:
3418	return Error(L: getTok().getLoc(), Msg: "invalid variable redefinition");
3419	case Variable::WARN_ON_REDEFINITION:
3420	if (Warning(L: NameLoc, Msg: "redefining '" + Name +
3421	"', already defined on the command line")) {
3422	return true;
3423	}
3424	break;
3425	default:
3426	break;
3427	}
3428	}
3429	Var.IsText = true;
3430	Var.TextValue = Value;
3431	Var.Redefinable = Variable::REDEFINABLE;
3432
3433	return false;
3434	}
3435	}
3436	if (DirKind == DK_TEXTEQU)
3437	return TokError(Msg: "expected <text> in '" + Twine(IDVal) + "' directive");
3438
3439	// Parse as expression assignment.
3440	const MCExpr *Expr;
3441	SMLoc EndLoc;
3442	if (parseExpression(Res&: Expr, EndLoc))
3443	return addErrorSuffix(Suffix: " in '" + Twine(IDVal) + "' directive");
3444	StringRef ExprAsString = StringRef(
3445	StartLoc.getPointer(), EndLoc.getPointer() - StartLoc.getPointer());
3446
3447	int64_t Value;
3448	if (!Expr->evaluateAsAbsolute(Res&: Value, Asm: getStreamer().getAssemblerPtr())) {
3449	if (DirKind == DK_ASSIGN)
3450	return Error(
3451	L: StartLoc,
3452	Msg: "expected absolute expression; not all symbols have known values",
3453	Range: {StartLoc, EndLoc});
3454
3455	// Not an absolute expression; define as a text replacement.
3456	if (!Var.IsText || Var.TextValue != ExprAsString) {
3457	switch (Var.Redefinable) {
3458	case Variable::NOT_REDEFINABLE:
3459	return Error(L: getTok().getLoc(), Msg: "invalid variable redefinition");
3460	case Variable::WARN_ON_REDEFINITION:
3461	if (Warning(L: NameLoc, Msg: "redefining '" + Name +
3462	"', already defined on the command line")) {
3463	return true;
3464	}
3465	break;
3466	default:
3467	break;
3468	}
3469	}
3470
3471	Var.IsText = true;
3472	Var.TextValue = ExprAsString.str();
3473	Var.Redefinable = Variable::REDEFINABLE;
3474
3475	return false;
3476	}
3477
3478	MCSymbol *Sym = getContext().getOrCreateSymbol(Name: Var.Name);
3479
3480	const MCConstantExpr *PrevValue =
3481	Sym->isVariable() ? dyn_cast_or_null<MCConstantExpr>(
3482	Val: Sym->getVariableValue(/*SetUsed=*/false))
3483	: nullptr;
3484	if (Var.IsText || !PrevValue || PrevValue->getValue() != Value) {
3485	switch (Var.Redefinable) {
3486	case Variable::NOT_REDEFINABLE:
3487	return Error(L: getTok().getLoc(), Msg: "invalid variable redefinition");
3488	case Variable::WARN_ON_REDEFINITION:
3489	if (Warning(L: NameLoc, Msg: "redefining '" + Name +
3490	"', already defined on the command line")) {
3491	return true;
3492	}
3493	break;
3494	default:
3495	break;
3496	}
3497	}
3498
3499	Var.IsText = false;
3500	Var.TextValue.clear();
3501	Var.Redefinable = (DirKind == DK_ASSIGN) ? Variable::REDEFINABLE
3502	: Variable::NOT_REDEFINABLE;
3503
3504	Sym->setRedefinable(Var.Redefinable != Variable::NOT_REDEFINABLE);
3505	Sym->setVariableValue(Expr);
3506	Sym->setExternal(false);
3507
3508	return false;
3509	}
3510
3511	bool MasmParser::parseEscapedString(std::string &Data) {
3512	if (check(P: getTok().isNot(K: AsmToken::String), Msg: "expected string"))
3513	return true;
3514
3515	Data = "";
3516	char Quote = getTok().getString().front();
3517	StringRef Str = getTok().getStringContents();
3518	Data.reserve(res: Str.size());
3519	for (size_t i = 0, e = Str.size(); i != e; ++i) {
3520	Data.push_back(c: Str[i]);
3521	if (Str[i] == Quote) {
3522	// MASM treats doubled delimiting quotes as an escaped delimiting quote.
3523	// If we're escaping the string's trailing delimiter, we're definitely
3524	// missing a quotation mark.
3525	if (i + 1 == Str.size())
3526	return Error(L: getTok().getLoc(), Msg: "missing quotation mark in string");
3527	if (Str[i + 1] == Quote)
3528	++i;
3529	}
3530	}
3531
3532	Lex();
3533	return false;
3534	}
3535
3536	bool MasmParser::parseAngleBracketString(std::string &Data) {
3537	SMLoc EndLoc, StartLoc = getTok().getLoc();
3538	if (isAngleBracketString(StrLoc&: StartLoc, EndLoc)) {
3539	const char *StartChar = StartLoc.getPointer() + 1;
3540	const char *EndChar = EndLoc.getPointer() - 1;
3541	jumpToLoc(Loc: EndLoc, InBuffer: CurBuffer, EndStatementAtEOF: EndStatementAtEOFStack.back());
3542	// Eat from '<' to '>'.
3543	Lex();
3544
3545	Data = angleBracketString(BracketContents: StringRef(StartChar, EndChar - StartChar));
3546	return false;
3547	}
3548	return true;
3549	}
3550
3551	/// textItem ::= textLiteral | textMacroID | % constExpr
3552	bool MasmParser::parseTextItem(std::string &Data) {
3553	switch (getTok().getKind()) {
3554	default:
3555	return true;
3556	case AsmToken::Percent: {
3557	int64_t Res;
3558	if (parseToken(T: AsmToken::Percent) || parseAbsoluteExpression(Res))
3559	return true;
3560	Data = std::to_string(val: Res);
3561	return false;
3562	}
3563	case AsmToken::Less:
3564	case AsmToken::LessEqual:
3565	case AsmToken::LessLess:
3566	case AsmToken::LessGreater:
3567	return parseAngleBracketString(Data);
3568	case AsmToken::Identifier: {
3569	// This must be a text macro; we need to expand it accordingly.
3570	StringRef ID;
3571	SMLoc StartLoc = getTok().getLoc();
3572	if (parseIdentifier(Res&: ID))
3573	return true;
3574	Data = ID.str();
3575
3576	bool Expanded = false;
3577	while (true) {
3578	// Try to resolve as a built-in text macro
3579	auto BuiltinIt = BuiltinSymbolMap.find(Key: ID.lower());
3580	if (BuiltinIt != BuiltinSymbolMap.end()) {
3581	std::optional<std::string> BuiltinText =
3582	evaluateBuiltinTextMacro(Symbol: BuiltinIt->getValue(), StartLoc);
3583	if (!BuiltinText) {
3584	// Not a text macro; break without substituting
3585	break;
3586	}
3587	Data = std::move(*BuiltinText);
3588	ID = StringRef(Data);
3589	Expanded = true;
3590	continue;
3591	}
3592
3593	// Try to resolve as a variable text macro
3594	auto VarIt = Variables.find(Key: ID.lower());
3595	if (VarIt != Variables.end()) {
3596	const Variable &Var = VarIt->getValue();
3597	if (!Var.IsText) {
3598	// Not a text macro; break without substituting
3599	break;
3600	}
3601	Data = Var.TextValue;
3602	ID = StringRef(Data);
3603	Expanded = true;
3604	continue;
3605	}
3606
3607	break;
3608	}
3609
3610	if (!Expanded) {
3611	// Not a text macro; not usable in TextItem context. Since we haven't used
3612	// the token, put it back for better error recovery.
3613	getLexer().UnLex(Token: AsmToken(AsmToken::Identifier, ID));
3614	return true;
3615	}
3616	return false;
3617	}
3618	}
3619	llvm_unreachable("unhandled token kind");
3620	}
3621
3622	/// parseDirectiveAscii:
3623	/// ::= ( .ascii | .asciz | .string ) [ "string" ( , "string" )* ]
3624	bool MasmParser::parseDirectiveAscii(StringRef IDVal, bool ZeroTerminated) {
3625	auto parseOp = [&]() -> bool {
3626	std::string Data;
3627	if (checkForValidSection() || parseEscapedString(Data))
3628	return true;
3629	getStreamer().emitBytes(Data);
3630	if (ZeroTerminated)
3631	getStreamer().emitBytes(Data: StringRef("\0", 1));
3632	return false;
3633	};
3634
3635	if (parseMany(parseOne: parseOp))
3636	return addErrorSuffix(Suffix: " in '" + Twine(IDVal) + "' directive");
3637	return false;
3638	}
3639
3640	bool MasmParser::emitIntValue(const MCExpr *Value, unsigned Size) {
3641	// Special case constant expressions to match code generator.
3642	if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Val: Value)) {
3643	assert(Size <= 8 && "Invalid size");
3644	int64_t IntValue = MCE->getValue();
3645	if (!isUIntN(N: 8 * Size, x: IntValue) && !isIntN(N: 8 * Size, x: IntValue))
3646	return Error(L: MCE->getLoc(), Msg: "out of range literal value");
3647	getStreamer().emitIntValue(Value: IntValue, Size);
3648	} else {
3649	const MCSymbolRefExpr *MSE = dyn_cast<MCSymbolRefExpr>(Val: Value);
3650	if (MSE && MSE->getSymbol().getName() == "?") {
3651	// ? initializer; treat as 0.
3652	getStreamer().emitIntValue(Value: 0, Size);
3653	} else {
3654	getStreamer().emitValue(Value, Size, Loc: Value->getLoc());
3655	}
3656	}
3657	return false;
3658	}
3659
3660	bool MasmParser::parseScalarInitializer(unsigned Size,
3661	SmallVectorImpl<const MCExpr *> &Values,
3662	unsigned StringPadLength) {
3663	if (Size == 1 && getTok().is(K: AsmToken::String)) {
3664	std::string Value;
3665	if (parseEscapedString(Data&: Value))
3666	return true;
3667	// Treat each character as an initializer.
3668	for (const unsigned char CharVal : Value)
3669	Values.push_back(Elt: MCConstantExpr::create(Value: CharVal, Ctx&: getContext()));
3670
3671	// Pad the string with spaces to the specified length.
3672	for (size_t i = Value.size(); i < StringPadLength; ++i)
3673	Values.push_back(Elt: MCConstantExpr::create(Value: ' ', Ctx&: getContext()));
3674	} else {
3675	const MCExpr *Value;
3676	if (parseExpression(Res&: Value))
3677	return true;
3678	if (getTok().is(K: AsmToken::Identifier) &&
3679	getTok().getString().equals_insensitive(RHS: "dup")) {
3680	Lex(); // Eat 'dup'.
3681	const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Val: Value);
3682	if (!MCE)
3683	return Error(L: Value->getLoc(),
3684	Msg: "cannot repeat value a non-constant number of times");
3685	const int64_t Repetitions = MCE->getValue();
3686	if (Repetitions < 0)
3687	return Error(L: Value->getLoc(),
3688	Msg: "cannot repeat value a negative number of times");
3689
3690	SmallVector<const MCExpr *, 1> DuplicatedValues;
3691	if (parseToken(T: AsmToken::LParen,
3692	Msg: "parentheses required for 'dup' contents") ||
3693	parseScalarInstList(Size, Values&: DuplicatedValues) || parseRParen())
3694	return true;
3695
3696	for (int i = 0; i < Repetitions; ++i)
3697	Values.append(in_start: DuplicatedValues.begin(), in_end: DuplicatedValues.end());
3698	} else {
3699	Values.push_back(Elt: Value);
3700	}
3701	}
3702	return false;
3703	}
3704
3705	bool MasmParser::parseScalarInstList(unsigned Size,
3706	SmallVectorImpl<const MCExpr *> &Values,
3707	const AsmToken::TokenKind EndToken) {
3708	while (getTok().isNot(K: EndToken) &&
3709	(EndToken != AsmToken::Greater ||
3710	getTok().isNot(K: AsmToken::GreaterGreater))) {
3711	parseScalarInitializer(Size, Values);
3712
3713	// If we see a comma, continue, and allow line continuation.
3714	if (!parseOptionalToken(T: AsmToken::Comma))
3715	break;
3716	parseOptionalToken(T: AsmToken::EndOfStatement);
3717	}
3718	return false;
3719	}
3720
3721	bool MasmParser::emitIntegralValues(unsigned Size, unsigned *Count) {
3722	SmallVector<const MCExpr *, 1> Values;
3723	if (checkForValidSection() || parseScalarInstList(Size, Values))
3724	return true;
3725
3726	for (const auto *Value : Values) {
3727	emitIntValue(Value, Size);
3728	}
3729	if (Count)
3730	*Count = Values.size();
3731	return false;
3732	}
3733
3734	// Add a field to the current structure.
3735	bool MasmParser::addIntegralField(StringRef Name, unsigned Size) {
3736	StructInfo &Struct = StructInProgress.back();
3737	FieldInfo &Field = Struct.addField(FieldName: Name, FT: FT_INTEGRAL, FieldAlignmentSize: Size);
3738	IntFieldInfo &IntInfo = Field.Contents.IntInfo;
3739
3740	Field.Type = Size;
3741
3742	if (parseScalarInstList(Size, Values&: IntInfo.Values))
3743	return true;
3744
3745	Field.SizeOf = Field.Type * IntInfo.Values.size();
3746	Field.LengthOf = IntInfo.Values.size();
3747	const unsigned FieldEnd = Field.Offset + Field.SizeOf;
3748	if (!Struct.IsUnion) {
3749	Struct.NextOffset = FieldEnd;
3750	}
3751	Struct.Size = std::max(a: Struct.Size, b: FieldEnd);
3752	return false;
3753	}
3754
3755	/// parseDirectiveValue
3756	/// ::= (byte | word | ... ) [ expression (, expression)* ]
3757	bool MasmParser::parseDirectiveValue(StringRef IDVal, unsigned Size) {
3758	if (StructInProgress.empty()) {
3759	// Initialize data value.
3760	if (emitIntegralValues(Size))
3761	return addErrorSuffix(Suffix: " in '" + Twine(IDVal) + "' directive");
3762	} else if (addIntegralField(Name: "", Size)) {
3763	return addErrorSuffix(Suffix: " in '" + Twine(IDVal) + "' directive");
3764	}
3765
3766	return false;
3767	}
3768
3769	/// parseDirectiveNamedValue
3770	/// ::= name (byte | word | ... ) [ expression (, expression)* ]
3771	bool MasmParser::parseDirectiveNamedValue(StringRef TypeName, unsigned Size,
3772	StringRef Name, SMLoc NameLoc) {
3773	if (StructInProgress.empty()) {
3774	// Initialize named data value.
3775	MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
3776	getStreamer().emitLabel(Symbol: Sym);
3777	unsigned Count;
3778	if (emitIntegralValues(Size, Count: &Count))
3779	return addErrorSuffix(Suffix: " in '" + Twine(TypeName) + "' directive");
3780
3781	AsmTypeInfo Type;
3782	Type.Name = TypeName;
3783	Type.Size = Size * Count;
3784	Type.ElementSize = Size;
3785	Type.Length = Count;
3786	KnownType[Name.lower()] = Type;
3787	} else if (addIntegralField(Name, Size)) {
3788	return addErrorSuffix(Suffix: " in '" + Twine(TypeName) + "' directive");
3789	}
3790
3791	return false;
3792	}
3793
3794	static bool parseHexOcta(MasmParser &Asm, uint64_t &hi, uint64_t &lo) {
3795	if (Asm.getTok().isNot(K: AsmToken::Integer) &&
3796	Asm.getTok().isNot(K: AsmToken::BigNum))
3797	return Asm.TokError(Msg: "unknown token in expression");
3798	SMLoc ExprLoc = Asm.getTok().getLoc();
3799	APInt IntValue = Asm.getTok().getAPIntVal();
3800	Asm.Lex();
3801	if (!IntValue.isIntN(N: 128))
3802	return Asm.Error(L: ExprLoc, Msg: "out of range literal value");
3803	if (!IntValue.isIntN(N: 64)) {
3804	hi = IntValue.getHiBits(numBits: IntValue.getBitWidth() - 64).getZExtValue();
3805	lo = IntValue.getLoBits(numBits: 64).getZExtValue();
3806	} else {
3807	hi = 0;
3808	lo = IntValue.getZExtValue();
3809	}
3810	return false;
3811	}
3812
3813	bool MasmParser::parseRealValue(const fltSemantics &Semantics, APInt &Res) {
3814	// We don't truly support arithmetic on floating point expressions, so we
3815	// have to manually parse unary prefixes.
3816	bool IsNeg = false;
3817	SMLoc SignLoc;
3818	if (getLexer().is(K: AsmToken::Minus)) {
3819	SignLoc = getLexer().getLoc();
3820	Lexer.Lex();
3821	IsNeg = true;
3822	} else if (getLexer().is(K: AsmToken::Plus)) {
3823	SignLoc = getLexer().getLoc();
3824	Lexer.Lex();
3825	}
3826
3827	if (Lexer.is(K: AsmToken::Error))
3828	return TokError(Msg: Lexer.getErr());
3829	if (Lexer.isNot(K: AsmToken::Integer) && Lexer.isNot(K: AsmToken::Real) &&
3830	Lexer.isNot(K: AsmToken::Identifier))
3831	return TokError(Msg: "unexpected token in directive");
3832
3833	// Convert to an APFloat.
3834	APFloat Value(Semantics);
3835	StringRef IDVal = getTok().getString();
3836	if (getLexer().is(K: AsmToken::Identifier)) {
3837	if (IDVal.equals_insensitive(RHS: "infinity") || IDVal.equals_insensitive(RHS: "inf"))
3838	Value = APFloat::getInf(Sem: Semantics);
3839	else if (IDVal.equals_insensitive(RHS: "nan"))
3840	Value = APFloat::getNaN(Sem: Semantics, Negative: false, payload: ~0);
3841	else if (IDVal.equals_insensitive(RHS: "?"))
3842	Value = APFloat::getZero(Sem: Semantics);
3843	else
3844	return TokError(Msg: "invalid floating point literal");
3845	} else if (IDVal.consume_back(Suffix: "r") || IDVal.consume_back(Suffix: "R")) {
3846	// MASM hexadecimal floating-point literal; no APFloat conversion needed.
3847	// To match ML64.exe, ignore the initial sign.
3848	unsigned SizeInBits = Value.getSizeInBits(Sem: Semantics);
3849	if (SizeInBits != (IDVal.size() << 2))
3850	return TokError(Msg: "invalid floating point literal");
3851
3852	// Consume the numeric token.
3853	Lex();
3854
3855	Res = APInt(SizeInBits, IDVal, 16);
3856	if (SignLoc.isValid())
3857	return Warning(L: SignLoc, Msg: "MASM-style hex floats ignore explicit sign");
3858	return false;
3859	} else if (errorToBool(
3860	Err: Value.convertFromString(IDVal, APFloat::rmNearestTiesToEven)
3861	.takeError())) {
3862	return TokError(Msg: "invalid floating point literal");
3863	}
3864	if (IsNeg)
3865	Value.changeSign();
3866
3867	// Consume the numeric token.
3868	Lex();
3869
3870	Res = Value.bitcastToAPInt();
3871
3872	return false;
3873	}
3874
3875	bool MasmParser::parseRealInstList(const fltSemantics &Semantics,
3876	SmallVectorImpl<APInt> &ValuesAsInt,
3877	const AsmToken::TokenKind EndToken) {
3878	while (getTok().isNot(K: EndToken) ||
3879	(EndToken == AsmToken::Greater &&
3880	getTok().isNot(K: AsmToken::GreaterGreater))) {
3881	const AsmToken NextTok = peekTok();
3882	if (NextTok.is(K: AsmToken::Identifier) &&
3883	NextTok.getString().equals_insensitive(RHS: "dup")) {
3884	const MCExpr *Value;
3885	if (parseExpression(Res&: Value) || parseToken(T: AsmToken::Identifier))
3886	return true;
3887	const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Val: Value);
3888	if (!MCE)
3889	return Error(L: Value->getLoc(),
3890	Msg: "cannot repeat value a non-constant number of times");
3891	const int64_t Repetitions = MCE->getValue();
3892	if (Repetitions < 0)
3893	return Error(L: Value->getLoc(),
3894	Msg: "cannot repeat value a negative number of times");
3895
3896	SmallVector<APInt, 1> DuplicatedValues;
3897	if (parseToken(T: AsmToken::LParen,
3898	Msg: "parentheses required for 'dup' contents") ||
3899	parseRealInstList(Semantics, ValuesAsInt&: DuplicatedValues) || parseRParen())
3900	return true;
3901
3902	for (int i = 0; i < Repetitions; ++i)
3903	ValuesAsInt.append(in_start: DuplicatedValues.begin(), in_end: DuplicatedValues.end());
3904	} else {
3905	APInt AsInt;
3906	if (parseRealValue(Semantics, Res&: AsInt))
3907	return true;
3908	ValuesAsInt.push_back(Elt: AsInt);
3909	}
3910
3911	// Continue if we see a comma. (Also, allow line continuation.)
3912	if (!parseOptionalToken(T: AsmToken::Comma))
3913	break;
3914	parseOptionalToken(T: AsmToken::EndOfStatement);
3915	}
3916
3917	return false;
3918	}
3919
3920	// Initialize real data values.
3921	bool MasmParser::emitRealValues(const fltSemantics &Semantics,
3922	unsigned *Count) {
3923	if (checkForValidSection())
3924	return true;
3925
3926	SmallVector<APInt, 1> ValuesAsInt;
3927	if (parseRealInstList(Semantics, ValuesAsInt))
3928	return true;
3929
3930	for (const APInt &AsInt : ValuesAsInt) {
3931	getStreamer().emitIntValue(Value: AsInt);
3932	}
3933	if (Count)
3934	*Count = ValuesAsInt.size();
3935	return false;
3936	}
3937
3938	// Add a real field to the current struct.
3939	bool MasmParser::addRealField(StringRef Name, const fltSemantics &Semantics,
3940	size_t Size) {
3941	StructInfo &Struct = StructInProgress.back();
3942	FieldInfo &Field = Struct.addField(FieldName: Name, FT: FT_REAL, FieldAlignmentSize: Size);
3943	RealFieldInfo &RealInfo = Field.Contents.RealInfo;
3944
3945	Field.SizeOf = 0;
3946
3947	if (parseRealInstList(Semantics, ValuesAsInt&: RealInfo.AsIntValues))
3948	return true;
3949
3950	Field.Type = RealInfo.AsIntValues.back().getBitWidth() / 8;
3951	Field.LengthOf = RealInfo.AsIntValues.size();
3952	Field.SizeOf = Field.Type * Field.LengthOf;
3953
3954	const unsigned FieldEnd = Field.Offset + Field.SizeOf;
3955	if (!Struct.IsUnion) {
3956	Struct.NextOffset = FieldEnd;
3957	}
3958	Struct.Size = std::max(a: Struct.Size, b: FieldEnd);
3959	return false;
3960	}
3961
3962	/// parseDirectiveRealValue
3963	/// ::= (real4 | real8 | real10) [ expression (, expression)* ]
3964	bool MasmParser::parseDirectiveRealValue(StringRef IDVal,
3965	const fltSemantics &Semantics,
3966	size_t Size) {
3967	if (StructInProgress.empty()) {
3968	// Initialize data value.
3969	if (emitRealValues(Semantics))
3970	return addErrorSuffix(Suffix: " in '" + Twine(IDVal) + "' directive");
3971	} else if (addRealField(Name: "", Semantics, Size)) {
3972	return addErrorSuffix(Suffix: " in '" + Twine(IDVal) + "' directive");
3973	}
3974	return false;
3975	}
3976
3977	/// parseDirectiveNamedRealValue
3978	/// ::= name (real4 | real8 | real10) [ expression (, expression)* ]
3979	bool MasmParser::parseDirectiveNamedRealValue(StringRef TypeName,
3980	const fltSemantics &Semantics,
3981	unsigned Size, StringRef Name,
3982	SMLoc NameLoc) {
3983	if (StructInProgress.empty()) {
3984	// Initialize named data value.
3985	MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
3986	getStreamer().emitLabel(Symbol: Sym);
3987	unsigned Count;
3988	if (emitRealValues(Semantics, Count: &Count))
3989	return addErrorSuffix(Suffix: " in '" + TypeName + "' directive");
3990
3991	AsmTypeInfo Type;
3992	Type.Name = TypeName;
3993	Type.Size = Size * Count;
3994	Type.ElementSize = Size;
3995	Type.Length = Count;
3996	KnownType[Name.lower()] = Type;
3997	} else if (addRealField(Name, Semantics, Size)) {
3998	return addErrorSuffix(Suffix: " in '" + TypeName + "' directive");
3999	}
4000	return false;
4001	}
4002
4003	bool MasmParser::parseOptionalAngleBracketOpen() {
4004	const AsmToken Tok = getTok();
4005	if (parseOptionalToken(T: AsmToken::LessLess)) {
4006	AngleBracketDepth++;
4007	Lexer.UnLex(Token: AsmToken(AsmToken::Less, Tok.getString().substr(Start: 1)));
4008	return true;
4009	} else if (parseOptionalToken(T: AsmToken::LessGreater)) {
4010	AngleBracketDepth++;
4011	Lexer.UnLex(Token: AsmToken(AsmToken::Greater, Tok.getString().substr(Start: 1)));
4012	return true;
4013	} else if (parseOptionalToken(T: AsmToken::Less)) {
4014	AngleBracketDepth++;
4015	return true;
4016	}
4017
4018	return false;
4019	}
4020
4021	bool MasmParser::parseAngleBracketClose(const Twine &Msg) {
4022	const AsmToken Tok = getTok();
4023	if (parseOptionalToken(T: AsmToken::GreaterGreater)) {
4024	Lexer.UnLex(Token: AsmToken(AsmToken::Greater, Tok.getString().substr(Start: 1)));
4025	} else if (parseToken(T: AsmToken::Greater, Msg)) {
4026	return true;
4027	}
4028	AngleBracketDepth--;
4029	return false;
4030	}
4031
4032	bool MasmParser::parseFieldInitializer(const FieldInfo &Field,
4033	const IntFieldInfo &Contents,
4034	FieldInitializer &Initializer) {
4035	SMLoc Loc = getTok().getLoc();
4036
4037	SmallVector<const MCExpr *, 1> Values;
4038	if (parseOptionalToken(T: AsmToken::LCurly)) {
4039	if (Field.LengthOf == 1 && Field.Type > 1)
4040	return Error(L: Loc, Msg: "Cannot initialize scalar field with array value");
4041	if (parseScalarInstList(Size: Field.Type, Values, EndToken: AsmToken::RCurly) ||
4042	parseToken(T: AsmToken::RCurly))
4043	return true;
4044	} else if (parseOptionalAngleBracketOpen()) {
4045	if (Field.LengthOf == 1 && Field.Type > 1)
4046	return Error(L: Loc, Msg: "Cannot initialize scalar field with array value");
4047	if (parseScalarInstList(Size: Field.Type, Values, EndToken: AsmToken::Greater) ||
4048	parseAngleBracketClose())
4049	return true;
4050	} else if (Field.LengthOf > 1 && Field.Type > 1) {
4051	return Error(L: Loc, Msg: "Cannot initialize array field with scalar value");
4052	} else if (parseScalarInitializer(Size: Field.Type, Values,
4053	/*StringPadLength=*/Field.LengthOf)) {
4054	return true;
4055	}
4056
4057	if (Values.size() > Field.LengthOf) {
4058	return Error(L: Loc, Msg: "Initializer too long for field; expected at most " +
4059	std::to_string(val: Field.LengthOf) + " elements, got " +
4060	std::to_string(val: Values.size()));
4061	}
4062	// Default-initialize all remaining values.
4063	Values.append(in_start: Contents.Values.begin() + Values.size(), in_end: Contents.Values.end());
4064
4065	Initializer = FieldInitializer(std::move(Values));
4066	return false;
4067	}
4068
4069	bool MasmParser::parseFieldInitializer(const FieldInfo &Field,
4070	const RealFieldInfo &Contents,
4071	FieldInitializer &Initializer) {
4072	const fltSemantics *Semantics;
4073	switch (Field.Type) {
4074	case 4:
4075	Semantics = &APFloat::IEEEsingle();
4076	break;
4077	case 8:
4078	Semantics = &APFloat::IEEEdouble();
4079	break;
4080	case 10:
4081	Semantics = &APFloat::x87DoubleExtended();
4082	break;
4083	default:
4084	llvm_unreachable("unknown real field type");
4085	}
4086
4087	SMLoc Loc = getTok().getLoc();
4088
4089	SmallVector<APInt, 1> AsIntValues;
4090	if (parseOptionalToken(T: AsmToken::LCurly)) {
4091	if (Field.LengthOf == 1)
4092	return Error(L: Loc, Msg: "Cannot initialize scalar field with array value");
4093	if (parseRealInstList(Semantics: *Semantics, ValuesAsInt&: AsIntValues, EndToken: AsmToken::RCurly) ||
4094	parseToken(T: AsmToken::RCurly))
4095	return true;
4096	} else if (parseOptionalAngleBracketOpen()) {
4097	if (Field.LengthOf == 1)
4098	return Error(L: Loc, Msg: "Cannot initialize scalar field with array value");
4099	if (parseRealInstList(Semantics: *Semantics, ValuesAsInt&: AsIntValues, EndToken: AsmToken::Greater) ||
4100	parseAngleBracketClose())
4101	return true;
4102	} else if (Field.LengthOf > 1) {
4103	return Error(L: Loc, Msg: "Cannot initialize array field with scalar value");
4104	} else {
4105	AsIntValues.emplace_back();
4106	if (parseRealValue(Semantics: *Semantics, Res&: AsIntValues.back()))
4107	return true;
4108	}
4109
4110	if (AsIntValues.size() > Field.LengthOf) {
4111	return Error(L: Loc, Msg: "Initializer too long for field; expected at most " +
4112	std::to_string(val: Field.LengthOf) + " elements, got " +
4113	std::to_string(val: AsIntValues.size()));
4114	}
4115	// Default-initialize all remaining values.
4116	AsIntValues.append(in_start: Contents.AsIntValues.begin() + AsIntValues.size(),
4117	in_end: Contents.AsIntValues.end());
4118
4119	Initializer = FieldInitializer(std::move(AsIntValues));
4120	return false;
4121	}
4122
4123	bool MasmParser::parseFieldInitializer(const FieldInfo &Field,
4124	const StructFieldInfo &Contents,
4125	FieldInitializer &Initializer) {
4126	SMLoc Loc = getTok().getLoc();
4127
4128	std::vector<StructInitializer> Initializers;
4129	if (Field.LengthOf > 1) {
4130	if (parseOptionalToken(T: AsmToken::LCurly)) {
4131	if (parseStructInstList(Structure: Contents.Structure, Initializers,
4132	EndToken: AsmToken::RCurly) ||
4133	parseToken(T: AsmToken::RCurly))
4134	return true;
4135	} else if (parseOptionalAngleBracketOpen()) {
4136	if (parseStructInstList(Structure: Contents.Structure, Initializers,
4137	EndToken: AsmToken::Greater) ||
4138	parseAngleBracketClose())
4139	return true;
4140	} else {
4141	return Error(L: Loc, Msg: "Cannot initialize array field with scalar value");
4142	}
4143	} else {
4144	Initializers.emplace_back();
4145	if (parseStructInitializer(Structure: Contents.Structure, Initializer&: Initializers.back()))
4146	return true;
4147	}
4148
4149	if (Initializers.size() > Field.LengthOf) {
4150	return Error(L: Loc, Msg: "Initializer too long for field; expected at most " +
4151	std::to_string(val: Field.LengthOf) + " elements, got " +
4152	std::to_string(val: Initializers.size()));
4153	}
4154	// Default-initialize all remaining values.
4155	Initializers.insert(position: Initializers.end(),
4156	first: Contents.Initializers.begin() + Initializers.size(),
4157	last: Contents.Initializers.end());
4158
4159	Initializer = FieldInitializer(std::move(Initializers), Contents.Structure);
4160	return false;
4161	}
4162
4163	bool MasmParser::parseFieldInitializer(const FieldInfo &Field,
4164	FieldInitializer &Initializer) {
4165	switch (Field.Contents.FT) {
4166	case FT_INTEGRAL:
4167	return parseFieldInitializer(Field, Contents: Field.Contents.IntInfo, Initializer);
4168	case FT_REAL:
4169	return parseFieldInitializer(Field, Contents: Field.Contents.RealInfo, Initializer);
4170	case FT_STRUCT:
4171	return parseFieldInitializer(Field, Contents: Field.Contents.StructInfo, Initializer);
4172	}
4173	llvm_unreachable("Unhandled FieldType enum");
4174	}
4175
4176	bool MasmParser::parseStructInitializer(const StructInfo &Structure,
4177	StructInitializer &Initializer) {
4178	const AsmToken FirstToken = getTok();
4179
4180	std::optional<AsmToken::TokenKind> EndToken;
4181	if (parseOptionalToken(T: AsmToken::LCurly)) {
4182	EndToken = AsmToken::RCurly;
4183	} else if (parseOptionalAngleBracketOpen()) {
4184	EndToken = AsmToken::Greater;
4185	AngleBracketDepth++;
4186	} else if (FirstToken.is(K: AsmToken::Identifier) &&
4187	FirstToken.getString() == "?") {
4188	// ? initializer; leave EndToken uninitialized to treat as empty.
4189	if (parseToken(T: AsmToken::Identifier))
4190	return true;
4191	} else {
4192	return Error(L: FirstToken.getLoc(), Msg: "Expected struct initializer");
4193	}
4194
4195	auto &FieldInitializers = Initializer.FieldInitializers;
4196	size_t FieldIndex = 0;
4197	if (EndToken) {
4198	// Initialize all fields with given initializers.
4199	while (getTok().isNot(K: *EndToken) && FieldIndex < Structure.Fields.size()) {
4200	const FieldInfo &Field = Structure.Fields[FieldIndex++];
4201	if (parseOptionalToken(T: AsmToken::Comma)) {
4202	// Empty initializer; use the default and continue. (Also, allow line
4203	// continuation.)
4204	FieldInitializers.push_back(x: Field.Contents);
4205	parseOptionalToken(T: AsmToken::EndOfStatement);
4206	continue;
4207	}
4208	FieldInitializers.emplace_back(args: Field.Contents.FT);
4209	if (parseFieldInitializer(Field, Initializer&: FieldInitializers.back()))
4210	return true;
4211
4212	// Continue if we see a comma. (Also, allow line continuation.)
4213	SMLoc CommaLoc = getTok().getLoc();
4214	if (!parseOptionalToken(T: AsmToken::Comma))
4215	break;
4216	if (FieldIndex == Structure.Fields.size())
4217	return Error(L: CommaLoc, Msg: "'" + Structure.Name +
4218	"' initializer initializes too many fields");
4219	parseOptionalToken(T: AsmToken::EndOfStatement);
4220	}
4221	}
4222	// Default-initialize all remaining fields.
4223	for (const FieldInfo &Field : llvm::drop_begin(RangeOrContainer: Structure.Fields, N: FieldIndex))
4224	FieldInitializers.push_back(x: Field.Contents);
4225
4226	if (EndToken) {
4227	if (*EndToken == AsmToken::Greater)
4228	return parseAngleBracketClose();
4229
4230	return parseToken(T: *EndToken);
4231	}
4232
4233	return false;
4234	}
4235
4236	bool MasmParser::parseStructInstList(
4237	const StructInfo &Structure, std::vector<StructInitializer> &Initializers,
4238	const AsmToken::TokenKind EndToken) {
4239	while (getTok().isNot(K: EndToken) ||
4240	(EndToken == AsmToken::Greater &&
4241	getTok().isNot(K: AsmToken::GreaterGreater))) {
4242	const AsmToken NextTok = peekTok();
4243	if (NextTok.is(K: AsmToken::Identifier) &&
4244	NextTok.getString().equals_insensitive(RHS: "dup")) {
4245	const MCExpr *Value;
4246	if (parseExpression(Res&: Value) || parseToken(T: AsmToken::Identifier))
4247	return true;
4248	const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Val: Value);
4249	if (!MCE)
4250	return Error(L: Value->getLoc(),
4251	Msg: "cannot repeat value a non-constant number of times");
4252	const int64_t Repetitions = MCE->getValue();
4253	if (Repetitions < 0)
4254	return Error(L: Value->getLoc(),
4255	Msg: "cannot repeat value a negative number of times");
4256
4257	std::vector<StructInitializer> DuplicatedValues;
4258	if (parseToken(T: AsmToken::LParen,
4259	Msg: "parentheses required for 'dup' contents") ||
4260	parseStructInstList(Structure, Initializers&: DuplicatedValues) || parseRParen())
4261	return true;
4262
4263	for (int i = 0; i < Repetitions; ++i)
4264	llvm::append_range(C&: Initializers, R&: DuplicatedValues);
4265	} else {
4266	Initializers.emplace_back();
4267	if (parseStructInitializer(Structure, Initializer&: Initializers.back()))
4268	return true;
4269	}
4270
4271	// Continue if we see a comma. (Also, allow line continuation.)
4272	if (!parseOptionalToken(T: AsmToken::Comma))
4273	break;
4274	parseOptionalToken(T: AsmToken::EndOfStatement);
4275	}
4276
4277	return false;
4278	}
4279
4280	bool MasmParser::emitFieldValue(const FieldInfo &Field,
4281	const IntFieldInfo &Contents) {
4282	// Default-initialize all values.
4283	for (const MCExpr *Value : Contents.Values) {
4284	if (emitIntValue(Value, Size: Field.Type))
4285	return true;
4286	}
4287	return false;
4288	}
4289
4290	bool MasmParser::emitFieldValue(const FieldInfo &Field,
4291	const RealFieldInfo &Contents) {
4292	for (const APInt &AsInt : Contents.AsIntValues) {
4293	getStreamer().emitIntValue(Value: AsInt.getLimitedValue(),
4294	Size: AsInt.getBitWidth() / 8);
4295	}
4296	return false;
4297	}
4298
4299	bool MasmParser::emitFieldValue(const FieldInfo &Field,
4300	const StructFieldInfo &Contents) {
4301	for (const auto &Initializer : Contents.Initializers) {
4302	size_t Index = 0, Offset = 0;
4303	for (const auto &SubField : Contents.Structure.Fields) {
4304	getStreamer().emitZeros(NumBytes: SubField.Offset - Offset);
4305	Offset = SubField.Offset + SubField.SizeOf;
4306	emitFieldInitializer(Field: SubField, Initializer: Initializer.FieldInitializers[Index++]);
4307	}
4308	}
4309	return false;
4310	}
4311
4312	bool MasmParser::emitFieldValue(const FieldInfo &Field) {
4313	switch (Field.Contents.FT) {
4314	case FT_INTEGRAL:
4315	return emitFieldValue(Field, Contents: Field.Contents.IntInfo);
4316	case FT_REAL:
4317	return emitFieldValue(Field, Contents: Field.Contents.RealInfo);
4318	case FT_STRUCT:
4319	return emitFieldValue(Field, Contents: Field.Contents.StructInfo);
4320	}
4321	llvm_unreachable("Unhandled FieldType enum");
4322	}
4323
4324	bool MasmParser::emitFieldInitializer(const FieldInfo &Field,
4325	const IntFieldInfo &Contents,
4326	const IntFieldInfo &Initializer) {
4327	for (const auto &Value : Initializer.Values) {
4328	if (emitIntValue(Value, Size: Field.Type))
4329	return true;
4330	}
4331	// Default-initialize all remaining values.
4332	for (const auto &Value :
4333	llvm::drop_begin(RangeOrContainer: Contents.Values, N: Initializer.Values.size())) {
4334	if (emitIntValue(Value, Size: Field.Type))
4335	return true;
4336	}
4337	return false;
4338	}
4339
4340	bool MasmParser::emitFieldInitializer(const FieldInfo &Field,
4341	const RealFieldInfo &Contents,
4342	const RealFieldInfo &Initializer) {
4343	for (const auto &AsInt : Initializer.AsIntValues) {
4344	getStreamer().emitIntValue(Value: AsInt.getLimitedValue(),
4345	Size: AsInt.getBitWidth() / 8);
4346	}
4347	// Default-initialize all remaining values.
4348	for (const auto &AsInt :
4349	llvm::drop_begin(RangeOrContainer: Contents.AsIntValues, N: Initializer.AsIntValues.size())) {
4350	getStreamer().emitIntValue(Value: AsInt.getLimitedValue(),
4351	Size: AsInt.getBitWidth() / 8);
4352	}
4353	return false;
4354	}
4355
4356	bool MasmParser::emitFieldInitializer(const FieldInfo &Field,
4357	const StructFieldInfo &Contents,
4358	const StructFieldInfo &Initializer) {
4359	for (const auto &Init : Initializer.Initializers) {
4360	if (emitStructInitializer(Structure: Contents.Structure, Initializer: Init))
4361	return true;
4362	}
4363	// Default-initialize all remaining values.
4364	for (const auto &Init : llvm::drop_begin(RangeOrContainer: Contents.Initializers,
4365	N: Initializer.Initializers.size())) {
4366	if (emitStructInitializer(Structure: Contents.Structure, Initializer: Init))
4367	return true;
4368	}
4369	return false;
4370	}
4371
4372	bool MasmParser::emitFieldInitializer(const FieldInfo &Field,
4373	const FieldInitializer &Initializer) {
4374	switch (Field.Contents.FT) {
4375	case FT_INTEGRAL:
4376	return emitFieldInitializer(Field, Contents: Field.Contents.IntInfo,
4377	Initializer: Initializer.IntInfo);
4378	case FT_REAL:
4379	return emitFieldInitializer(Field, Contents: Field.Contents.RealInfo,
4380	Initializer: Initializer.RealInfo);
4381	case FT_STRUCT:
4382	return emitFieldInitializer(Field, Contents: Field.Contents.StructInfo,
4383	Initializer: Initializer.StructInfo);
4384	}
4385	llvm_unreachable("Unhandled FieldType enum");
4386	}
4387
4388	bool MasmParser::emitStructInitializer(const StructInfo &Structure,
4389	const StructInitializer &Initializer) {
4390	if (!Structure.Initializable)
4391	return Error(L: getLexer().getLoc(),
4392	Msg: "cannot initialize a value of type '" + Structure.Name +
4393	"'; 'org' was used in the type's declaration");
4394	size_t Index = 0, Offset = 0;
4395	for (const auto &Init : Initializer.FieldInitializers) {
4396	const auto &Field = Structure.Fields[Index++];
4397	getStreamer().emitZeros(NumBytes: Field.Offset - Offset);
4398	Offset = Field.Offset + Field.SizeOf;
4399	if (emitFieldInitializer(Field, Initializer: Init))
4400	return true;
4401	}
4402	// Default-initialize all remaining fields.
4403	for (const auto &Field : llvm::drop_begin(
4404	RangeOrContainer: Structure.Fields, N: Initializer.FieldInitializers.size())) {
4405	getStreamer().emitZeros(NumBytes: Field.Offset - Offset);
4406	Offset = Field.Offset + Field.SizeOf;
4407	if (emitFieldValue(Field))
4408	return true;
4409	}
4410	// Add final padding.
4411	if (Offset != Structure.Size)
4412	getStreamer().emitZeros(NumBytes: Structure.Size - Offset);
4413	return false;
4414	}
4415
4416	// Set data values from initializers.
4417	bool MasmParser::emitStructValues(const StructInfo &Structure,
4418	unsigned *Count) {
4419	std::vector<StructInitializer> Initializers;
4420	if (parseStructInstList(Structure, Initializers))
4421	return true;
4422
4423	for (const auto &Initializer : Initializers) {
4424	if (emitStructInitializer(Structure, Initializer))
4425	return true;
4426	}
4427
4428	if (Count)
4429	*Count = Initializers.size();
4430	return false;
4431	}
4432
4433	// Declare a field in the current struct.
4434	bool MasmParser::addStructField(StringRef Name, const StructInfo &Structure) {
4435	StructInfo &OwningStruct = StructInProgress.back();
4436	FieldInfo &Field =
4437	OwningStruct.addField(FieldName: Name, FT: FT_STRUCT, FieldAlignmentSize: Structure.AlignmentSize);
4438	StructFieldInfo &StructInfo = Field.Contents.StructInfo;
4439
4440	StructInfo.Structure = Structure;
4441	Field.Type = Structure.Size;
4442
4443	if (parseStructInstList(Structure, Initializers&: StructInfo.Initializers))
4444	return true;
4445
4446	Field.LengthOf = StructInfo.Initializers.size();
4447	Field.SizeOf = Field.Type * Field.LengthOf;
4448
4449	const unsigned FieldEnd = Field.Offset + Field.SizeOf;
4450	if (!OwningStruct.IsUnion) {
4451	OwningStruct.NextOffset = FieldEnd;
4452	}
4453	OwningStruct.Size = std::max(a: OwningStruct.Size, b: FieldEnd);
4454
4455	return false;
4456	}
4457
4458	/// parseDirectiveStructValue
4459	/// ::= struct-id (<struct-initializer> | {struct-initializer})
4460	/// [, (<struct-initializer> | {struct-initializer})]*
4461	bool MasmParser::parseDirectiveStructValue(const StructInfo &Structure,
4462	StringRef Directive, SMLoc DirLoc) {
4463	if (StructInProgress.empty()) {
4464	if (emitStructValues(Structure))
4465	return true;
4466	} else if (addStructField(Name: "", Structure)) {
4467	return addErrorSuffix(Suffix: " in '" + Twine(Directive) + "' directive");
4468	}
4469
4470	return false;
4471	}
4472
4473	/// parseDirectiveNamedValue
4474	/// ::= name (byte | word | ... ) [ expression (, expression)* ]
4475	bool MasmParser::parseDirectiveNamedStructValue(const StructInfo &Structure,
4476	StringRef Directive,
4477	SMLoc DirLoc, StringRef Name) {
4478	if (StructInProgress.empty()) {
4479	// Initialize named data value.
4480	MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
4481	getStreamer().emitLabel(Symbol: Sym);
4482	unsigned Count;
4483	if (emitStructValues(Structure, Count: &Count))
4484	return true;
4485	AsmTypeInfo Type;
4486	Type.Name = Structure.Name;
4487	Type.Size = Structure.Size * Count;
4488	Type.ElementSize = Structure.Size;
4489	Type.Length = Count;
4490	KnownType[Name.lower()] = Type;
4491	} else if (addStructField(Name, Structure)) {
4492	return addErrorSuffix(Suffix: " in '" + Twine(Directive) + "' directive");
4493	}
4494
4495	return false;
4496	}
4497
4498	/// parseDirectiveStruct
4499	/// ::= <name> (STRUC | STRUCT | UNION) [fieldAlign] [, NONUNIQUE]
4500	/// (dataDir | generalDir | offsetDir | nestedStruct)+
4501	/// <name> ENDS
4502	////// dataDir = data declaration
4503	////// offsetDir = EVEN, ORG, ALIGN
4504	bool MasmParser::parseDirectiveStruct(StringRef Directive,
4505	DirectiveKind DirKind, StringRef Name,
4506	SMLoc NameLoc) {
4507	// We ignore NONUNIQUE; we do not support OPTION M510 or OPTION OLDSTRUCTS
4508	// anyway, so all field accesses must be qualified.
4509	AsmToken NextTok = getTok();
4510	int64_t AlignmentValue = 1;
4511	if (NextTok.isNot(K: AsmToken::Comma) &&
4512	NextTok.isNot(K: AsmToken::EndOfStatement) &&
4513	parseAbsoluteExpression(Res&: AlignmentValue)) {
4514	return addErrorSuffix(Suffix: " in alignment value for '" + Twine(Directive) +
4515	"' directive");
4516	}
4517	if (!isPowerOf2_64(Value: AlignmentValue)) {
4518	return Error(L: NextTok.getLoc(), Msg: "alignment must be a power of two; was " +
4519	std::to_string(val: AlignmentValue));
4520	}
4521
4522	StringRef Qualifier;
4523	SMLoc QualifierLoc;
4524	if (parseOptionalToken(T: AsmToken::Comma)) {
4525	QualifierLoc = getTok().getLoc();
4526	if (parseIdentifier(Res&: Qualifier))
4527	return addErrorSuffix(Suffix: " in '" + Twine(Directive) + "' directive");
4528	if (!Qualifier.equals_insensitive(RHS: "nonunique"))
4529	return Error(L: QualifierLoc, Msg: "Unrecognized qualifier for '" +
4530	Twine(Directive) +
4531	"' directive; expected none or NONUNIQUE");
4532	}
4533
4534	if (parseEOL())
4535	return addErrorSuffix(Suffix: " in '" + Twine(Directive) + "' directive");
4536
4537	StructInProgress.emplace_back(Args&: Name, Args: DirKind == DK_UNION, Args&: AlignmentValue);
4538	return false;
4539	}
4540
4541	/// parseDirectiveNestedStruct
4542	/// ::= (STRUC | STRUCT | UNION) [name]
4543	/// (dataDir | generalDir | offsetDir | nestedStruct)+
4544	/// ENDS
4545	bool MasmParser::parseDirectiveNestedStruct(StringRef Directive,
4546	DirectiveKind DirKind) {
4547	if (StructInProgress.empty())
4548	return TokError(Msg: "missing name in top-level '" + Twine(Directive) +
4549	"' directive");
4550
4551	StringRef Name;
4552	if (getTok().is(K: AsmToken::Identifier)) {
4553	Name = getTok().getIdentifier();
4554	parseToken(T: AsmToken::Identifier);
4555	}
4556	if (parseEOL())
4557	return addErrorSuffix(Suffix: " in '" + Twine(Directive) + "' directive");
4558
4559	// Reserve space to ensure Alignment doesn't get invalidated when
4560	// StructInProgress grows.
4561	StructInProgress.reserve(N: StructInProgress.size() + 1);
4562	StructInProgress.emplace_back(Args&: Name, Args: DirKind == DK_UNION,
4563	Args&: StructInProgress.back().Alignment);
4564	return false;
4565	}
4566
4567	bool MasmParser::parseDirectiveEnds(StringRef Name, SMLoc NameLoc) {
4568	if (StructInProgress.empty())
4569	return Error(L: NameLoc, Msg: "ENDS directive without matching STRUC/STRUCT/UNION");
4570	if (StructInProgress.size() > 1)
4571	return Error(L: NameLoc, Msg: "unexpected name in nested ENDS directive");
4572	if (StructInProgress.back().Name.compare_insensitive(RHS: Name))
4573	return Error(L: NameLoc, Msg: "mismatched name in ENDS directive; expected '" +
4574	StructInProgress.back().Name + "'");
4575	StructInfo Structure = StructInProgress.pop_back_val();
4576	// Pad to make the structure's size divisible by the smaller of its alignment
4577	// and the size of its largest field.
4578	Structure.Size = llvm::alignTo(
4579	Value: Structure.Size, Align: std::min(a: Structure.Alignment, b: Structure.AlignmentSize));
4580	Structs[Name.lower()] = Structure;
4581
4582	if (parseEOL())
4583	return addErrorSuffix(Suffix: " in ENDS directive");
4584
4585	return false;
4586	}
4587
4588	bool MasmParser::parseDirectiveNestedEnds() {
4589	if (StructInProgress.empty())
4590	return TokError(Msg: "ENDS directive without matching STRUC/STRUCT/UNION");
4591	if (StructInProgress.size() == 1)
4592	return TokError(Msg: "missing name in top-level ENDS directive");
4593
4594	if (parseEOL())
4595	return addErrorSuffix(Suffix: " in nested ENDS directive");
4596
4597	StructInfo Structure = StructInProgress.pop_back_val();
4598	// Pad to make the structure's size divisible by its alignment.
4599	Structure.Size = llvm::alignTo(Value: Structure.Size, Align: Structure.Alignment);
4600
4601	StructInfo &ParentStruct = StructInProgress.back();
4602	if (Structure.Name.empty()) {
4603	// Anonymous substructures' fields are addressed as if they belong to the
4604	// parent structure - so we transfer them to the parent here.
4605	const size_t OldFields = ParentStruct.Fields.size();
4606	ParentStruct.Fields.insert(
4607	position: ParentStruct.Fields.end(),
4608	first: std::make_move_iterator(i: Structure.Fields.begin()),
4609	last: std::make_move_iterator(i: Structure.Fields.end()));
4610	for (const auto &FieldByName : Structure.FieldsByName) {
4611	ParentStruct.FieldsByName[FieldByName.getKey()] =
4612	FieldByName.getValue() + OldFields;
4613	}
4614
4615	unsigned FirstFieldOffset = 0;
4616	if (!Structure.Fields.empty() && !ParentStruct.IsUnion) {
4617	FirstFieldOffset = llvm::alignTo(
4618	Value: ParentStruct.NextOffset,
4619	Align: std::min(a: ParentStruct.Alignment, b: Structure.AlignmentSize));
4620	}
4621
4622	if (ParentStruct.IsUnion) {
4623	ParentStruct.Size = std::max(a: ParentStruct.Size, b: Structure.Size);
4624	} else {
4625	for (auto &Field : llvm::drop_begin(RangeOrContainer&: ParentStruct.Fields, N: OldFields))
4626	Field.Offset += FirstFieldOffset;
4627
4628	const unsigned StructureEnd = FirstFieldOffset + Structure.Size;
4629	if (!ParentStruct.IsUnion) {
4630	ParentStruct.NextOffset = StructureEnd;
4631	}
4632	ParentStruct.Size = std::max(a: ParentStruct.Size, b: StructureEnd);
4633	}
4634	} else {
4635	FieldInfo &Field = ParentStruct.addField(FieldName: Structure.Name, FT: FT_STRUCT,
4636	FieldAlignmentSize: Structure.AlignmentSize);
4637	StructFieldInfo &StructInfo = Field.Contents.StructInfo;
4638	Field.Type = Structure.Size;
4639	Field.LengthOf = 1;
4640	Field.SizeOf = Structure.Size;
4641
4642	const unsigned StructureEnd = Field.Offset + Field.SizeOf;
4643	if (!ParentStruct.IsUnion) {
4644	ParentStruct.NextOffset = StructureEnd;
4645	}
4646	ParentStruct.Size = std::max(a: ParentStruct.Size, b: StructureEnd);
4647
4648	StructInfo.Structure = Structure;
4649	StructInfo.Initializers.emplace_back();
4650	auto &FieldInitializers = StructInfo.Initializers.back().FieldInitializers;
4651	for (const auto &SubField : Structure.Fields) {
4652	FieldInitializers.push_back(x: SubField.Contents);
4653	}
4654	}
4655
4656	return false;
4657	}
4658
4659	/// parseDirectiveOrg
4660	/// ::= org expression
4661	bool MasmParser::parseDirectiveOrg() {
4662	const MCExpr *Offset;
4663	SMLoc OffsetLoc = Lexer.getLoc();
4664	if (checkForValidSection() || parseExpression(Res&: Offset))
4665	return true;
4666	if (parseEOL())
4667	return addErrorSuffix(Suffix: " in 'org' directive");
4668
4669	if (StructInProgress.empty()) {
4670	// Not in a struct; change the offset for the next instruction or data
4671	if (checkForValidSection())
4672	return addErrorSuffix(Suffix: " in 'org' directive");
4673
4674	getStreamer().emitValueToOffset(Offset, Value: 0, Loc: OffsetLoc);
4675	} else {
4676	// Offset the next field of this struct
4677	StructInfo &Structure = StructInProgress.back();
4678	int64_t OffsetRes;
4679	if (!Offset->evaluateAsAbsolute(Res&: OffsetRes, Asm: getStreamer().getAssemblerPtr()))
4680	return Error(L: OffsetLoc,
4681	Msg: "expected absolute expression in 'org' directive");
4682	if (OffsetRes < 0)
4683	return Error(
4684	L: OffsetLoc,
4685	Msg: "expected non-negative value in struct's 'org' directive; was " +
4686	std::to_string(val: OffsetRes));
4687	Structure.NextOffset = static_cast<unsigned>(OffsetRes);
4688
4689	// ORG-affected structures cannot be initialized
4690	Structure.Initializable = false;
4691	}
4692
4693	return false;
4694	}
4695
4696	bool MasmParser::emitAlignTo(int64_t Alignment) {
4697	if (StructInProgress.empty()) {
4698	// Not in a struct; align the next instruction or data
4699	if (checkForValidSection())
4700	return true;
4701
4702	// Check whether we should use optimal code alignment for this align
4703	// directive.
4704	const MCSection *Section = getStreamer().getCurrentSectionOnly();
4705	assert(Section && "must have section to emit alignment");
4706	if (Section->useCodeAlign()) {
4707	getStreamer().emitCodeAlignment(Alignment: Align(Alignment),
4708	STI: &getTargetParser().getSTI(),
4709	/*MaxBytesToEmit=*/0);
4710	} else {
4711	// FIXME: Target specific behavior about how the "extra" bytes are filled.
4712	getStreamer().emitValueToAlignment(Alignment: Align(Alignment), /*Value=*/0,
4713	/*ValueSize=*/1,
4714	/*MaxBytesToEmit=*/0);
4715	}
4716	} else {
4717	// Align the next field of this struct
4718	StructInfo &Structure = StructInProgress.back();
4719	Structure.NextOffset = llvm::alignTo(Value: Structure.NextOffset, Align: Alignment);
4720	}
4721
4722	return false;
4723	}
4724
4725	/// parseDirectiveAlign
4726	/// ::= align expression
4727	bool MasmParser::parseDirectiveAlign() {
4728	SMLoc AlignmentLoc = getLexer().getLoc();
4729	int64_t Alignment;
4730
4731	// Ignore empty 'align' directives.
4732	if (getTok().is(K: AsmToken::EndOfStatement)) {
4733	return Warning(L: AlignmentLoc,
4734	Msg: "align directive with no operand is ignored") &&
4735	parseEOL();
4736	}
4737	if (parseAbsoluteExpression(Res&: Alignment) || parseEOL())
4738	return addErrorSuffix(Suffix: " in align directive");
4739
4740	// Always emit an alignment here even if we throw an error.
4741	bool ReturnVal = false;
4742
4743	// Reject alignments that aren't either a power of two or zero, for ML.exe
4744	// compatibility. Alignment of zero is silently rounded up to one.
4745	if (Alignment == 0)
4746	Alignment = 1;
4747	if (!isPowerOf2_64(Value: Alignment))
4748	ReturnVal |= Error(L: AlignmentLoc, Msg: "alignment must be a power of 2; was " +
4749	std::to_string(val: Alignment));
4750
4751	if (emitAlignTo(Alignment))
4752	ReturnVal |= addErrorSuffix(Suffix: " in align directive");
4753
4754	return ReturnVal;
4755	}
4756
4757	/// parseDirectiveEven
4758	/// ::= even
4759	bool MasmParser::parseDirectiveEven() {
4760	if (parseEOL() || emitAlignTo(Alignment: 2))
4761	return addErrorSuffix(Suffix: " in even directive");
4762
4763	return false;
4764	}
4765
4766	/// parseDirectiveFile
4767	/// ::= .file filename
4768	/// ::= .file number [directory] filename [md5 checksum] [source source-text]
4769	bool MasmParser::parseDirectiveFile(SMLoc DirectiveLoc) {
4770	// FIXME: I'm not sure what this is.
4771	int64_t FileNumber = -1;
4772	if (getLexer().is(K: AsmToken::Integer)) {
4773	FileNumber = getTok().getIntVal();
4774	Lex();
4775
4776	if (FileNumber < 0)
4777	return TokError(Msg: "negative file number");
4778	}
4779
4780	std::string Path;
4781
4782	// Usually the directory and filename together, otherwise just the directory.
4783	// Allow the strings to have escaped octal character sequence.
4784	if (check(P: getTok().isNot(K: AsmToken::String),
4785	Msg: "unexpected token in '.file' directive") ||
4786	parseEscapedString(Data&: Path))
4787	return true;
4788
4789	StringRef Directory;
4790	StringRef Filename;
4791	std::string FilenameData;
4792	if (getLexer().is(K: AsmToken::String)) {
4793	if (check(P: FileNumber == -1,
4794	Msg: "explicit path specified, but no file number") ||
4795	parseEscapedString(Data&: FilenameData))
4796	return true;
4797	Filename = FilenameData;
4798	Directory = Path;
4799	} else {
4800	Filename = Path;
4801	}
4802
4803	uint64_t MD5Hi, MD5Lo;
4804	bool HasMD5 = false;
4805
4806	std::optional<StringRef> Source;
4807	bool HasSource = false;
4808	std::string SourceString;
4809
4810	while (!parseOptionalToken(T: AsmToken::EndOfStatement)) {
4811	StringRef Keyword;
4812	if (check(P: getTok().isNot(K: AsmToken::Identifier),
4813	Msg: "unexpected token in '.file' directive") ||
4814	parseIdentifier(Res&: Keyword))
4815	return true;
4816	if (Keyword == "md5") {
4817	HasMD5 = true;
4818	if (check(P: FileNumber == -1,
4819	Msg: "MD5 checksum specified, but no file number") ||
4820	parseHexOcta(Asm&: *this, hi&: MD5Hi, lo&: MD5Lo))
4821	return true;
4822	} else if (Keyword == "source") {
4823	HasSource = true;
4824	if (check(P: FileNumber == -1,
4825	Msg: "source specified, but no file number") ||
4826	check(P: getTok().isNot(K: AsmToken::String),
4827	Msg: "unexpected token in '.file' directive") ||
4828	parseEscapedString(Data&: SourceString))
4829	return true;
4830	} else {
4831	return TokError(Msg: "unexpected token in '.file' directive");
4832	}
4833	}
4834
4835	if (FileNumber == -1) {
4836	// Ignore the directive if there is no number and the target doesn't support
4837	// numberless .file directives. This allows some portability of assembler
4838	// between different object file formats.
4839	if (getContext().getAsmInfo()->hasSingleParameterDotFile())
4840	getStreamer().emitFileDirective(Filename);
4841	} else {
4842	// In case there is a -g option as well as debug info from directive .file,
4843	// we turn off the -g option, directly use the existing debug info instead.
4844	// Throw away any implicit file table for the assembler source.
4845	if (Ctx.getGenDwarfForAssembly()) {
4846	Ctx.getMCDwarfLineTable(CUID: 0).resetFileTable();
4847	Ctx.setGenDwarfForAssembly(false);
4848	}
4849
4850	std::optional<MD5::MD5Result> CKMem;
4851	if (HasMD5) {
4852	MD5::MD5Result Sum;
4853	for (unsigned i = 0; i != 8; ++i) {
4854	Sum[i] = uint8_t(MD5Hi >> ((7 - i) * 8));
4855	Sum[i + 8] = uint8_t(MD5Lo >> ((7 - i) * 8));
4856	}
4857	CKMem = Sum;
4858	}
4859	if (HasSource) {
4860	char *SourceBuf = static_cast<char *>(Ctx.allocate(Size: SourceString.size()));
4861	memcpy(dest: SourceBuf, src: SourceString.data(), n: SourceString.size());
4862	Source = StringRef(SourceBuf, SourceString.size());
4863	}
4864	if (FileNumber == 0) {
4865	if (Ctx.getDwarfVersion() < 5)
4866	return Warning(L: DirectiveLoc, Msg: "file 0 not supported prior to DWARF-5");
4867	getStreamer().emitDwarfFile0Directive(Directory, Filename, Checksum: CKMem, Source);
4868	} else {
4869	Expected<unsigned> FileNumOrErr = getStreamer().tryEmitDwarfFileDirective(
4870	FileNo: FileNumber, Directory, Filename, Checksum: CKMem, Source);
4871	if (!FileNumOrErr)
4872	return Error(L: DirectiveLoc, Msg: toString(E: FileNumOrErr.takeError()));
4873	}
4874	// Alert the user if there are some .file directives with MD5 and some not.
4875	// But only do that once.
4876	if (!ReportedInconsistentMD5 && !Ctx.isDwarfMD5UsageConsistent(CUID: 0)) {
4877	ReportedInconsistentMD5 = true;
4878	return Warning(L: DirectiveLoc, Msg: "inconsistent use of MD5 checksums");
4879	}
4880	}
4881
4882	return false;
4883	}
4884
4885	/// parseDirectiveLine
4886	/// ::= .line [number]
4887	bool MasmParser::parseDirectiveLine() {
4888	int64_t LineNumber;
4889	if (getLexer().is(K: AsmToken::Integer)) {
4890	if (parseIntToken(V&: LineNumber, ErrMsg: "unexpected token in '.line' directive"))
4891	return true;
4892	(void)LineNumber;
4893	// FIXME: Do something with the .line.
4894	}
4895	if (parseEOL())
4896	return true;
4897
4898	return false;
4899	}
4900
4901	/// parseDirectiveLoc
4902	/// ::= .loc FileNumber [LineNumber] [ColumnPos] [basic_block] [prologue_end]
4903	/// [epilogue_begin] [is_stmt VALUE] [isa VALUE]
4904	/// The first number is a file number, must have been previously assigned with
4905	/// a .file directive, the second number is the line number and optionally the
4906	/// third number is a column position (zero if not specified). The remaining
4907	/// optional items are .loc sub-directives.
4908	bool MasmParser::parseDirectiveLoc() {
4909	int64_t FileNumber = 0, LineNumber = 0;
4910	SMLoc Loc = getTok().getLoc();
4911	if (parseIntToken(V&: FileNumber, ErrMsg: "unexpected token in '.loc' directive") ||
4912	check(P: FileNumber < 1 && Ctx.getDwarfVersion() < 5, Loc,
4913	Msg: "file number less than one in '.loc' directive") ||
4914	check(P: !getContext().isValidDwarfFileNumber(FileNumber), Loc,
4915	Msg: "unassigned file number in '.loc' directive"))
4916	return true;
4917
4918	// optional
4919	if (getLexer().is(K: AsmToken::Integer)) {
4920	LineNumber = getTok().getIntVal();
4921	if (LineNumber < 0)
4922	return TokError(Msg: "line number less than zero in '.loc' directive");
4923	Lex();
4924	}
4925
4926	int64_t ColumnPos = 0;
4927	if (getLexer().is(K: AsmToken::Integer)) {
4928	ColumnPos = getTok().getIntVal();
4929	if (ColumnPos < 0)
4930	return TokError(Msg: "column position less than zero in '.loc' directive");
4931	Lex();
4932	}
4933
4934	auto PrevFlags = getContext().getCurrentDwarfLoc().getFlags();
4935	unsigned Flags = PrevFlags & DWARF2_FLAG_IS_STMT;
4936	unsigned Isa = 0;
4937	int64_t Discriminator = 0;
4938
4939	auto parseLocOp = [&]() -> bool {
4940	StringRef Name;
4941	SMLoc Loc = getTok().getLoc();
4942	if (parseIdentifier(Res&: Name))
4943	return TokError(Msg: "unexpected token in '.loc' directive");
4944
4945	if (Name == "basic_block")
4946	Flags |= DWARF2_FLAG_BASIC_BLOCK;
4947	else if (Name == "prologue_end")
4948	Flags |= DWARF2_FLAG_PROLOGUE_END;
4949	else if (Name == "epilogue_begin")
4950	Flags |= DWARF2_FLAG_EPILOGUE_BEGIN;
4951	else if (Name == "is_stmt") {
4952	Loc = getTok().getLoc();
4953	const MCExpr *Value;
4954	if (parseExpression(Res&: Value))
4955	return true;
4956	// The expression must be the constant 0 or 1.
4957	if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Val: Value)) {
4958	int Value = MCE->getValue();
4959	if (Value == 0)
4960	Flags &= ~DWARF2_FLAG_IS_STMT;
4961	else if (Value == 1)
4962	Flags |= DWARF2_FLAG_IS_STMT;
4963	else
4964	return Error(L: Loc, Msg: "is_stmt value not 0 or 1");
4965	} else {
4966	return Error(L: Loc, Msg: "is_stmt value not the constant value of 0 or 1");
4967	}
4968	} else if (Name == "isa") {
4969	Loc = getTok().getLoc();
4970	const MCExpr *Value;
4971	if (parseExpression(Res&: Value))
4972	return true;
4973	// The expression must be a constant greater or equal to 0.
4974	if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Val: Value)) {
4975	int Value = MCE->getValue();
4976	if (Value < 0)
4977	return Error(L: Loc, Msg: "isa number less than zero");
4978	Isa = Value;
4979	} else {
4980	return Error(L: Loc, Msg: "isa number not a constant value");
4981	}
4982	} else if (Name == "discriminator") {
4983	if (parseAbsoluteExpression(Res&: Discriminator))
4984	return true;
4985	} else {
4986	return Error(L: Loc, Msg: "unknown sub-directive in '.loc' directive");
4987	}
4988	return false;
4989	};
4990
4991	if (parseMany(parseOne: parseLocOp, hasComma: false /*hasComma*/))
4992	return true;
4993
4994	getStreamer().emitDwarfLocDirective(FileNo: FileNumber, Line: LineNumber, Column: ColumnPos, Flags,
4995	Isa, Discriminator, FileName: StringRef());
4996
4997	return false;
4998	}
4999
5000	/// parseDirectiveStabs
5001	/// ::= .stabs string, number, number, number
5002	bool MasmParser::parseDirectiveStabs() {
5003	return TokError(Msg: "unsupported directive '.stabs'");
5004	}
5005
5006	/// parseDirectiveCVFile
5007	/// ::= .cv_file number filename [checksum] [checksumkind]
5008	bool MasmParser::parseDirectiveCVFile() {
5009	SMLoc FileNumberLoc = getTok().getLoc();
5010	int64_t FileNumber;
5011	std::string Filename;
5012	std::string Checksum;
5013	int64_t ChecksumKind = 0;
5014
5015	if (parseIntToken(V&: FileNumber,
5016	ErrMsg: "expected file number in '.cv_file' directive") ||
5017	check(P: FileNumber < 1, Loc: FileNumberLoc, Msg: "file number less than one") ||
5018	check(P: getTok().isNot(K: AsmToken::String),
5019	Msg: "unexpected token in '.cv_file' directive") ||
5020	parseEscapedString(Data&: Filename))
5021	return true;
5022	if (!parseOptionalToken(T: AsmToken::EndOfStatement)) {
5023	if (check(P: getTok().isNot(K: AsmToken::String),
5024	Msg: "unexpected token in '.cv_file' directive") ||
5025	parseEscapedString(Data&: Checksum) ||
5026	parseIntToken(V&: ChecksumKind,
5027	ErrMsg: "expected checksum kind in '.cv_file' directive") ||
5028	parseEOL())
5029	return true;
5030	}
5031
5032	Checksum = fromHex(Input: Checksum);
5033	void *CKMem = Ctx.allocate(Size: Checksum.size(), Align: 1);
5034	memcpy(dest: CKMem, src: Checksum.data(), n: Checksum.size());
5035	ArrayRef<uint8_t> ChecksumAsBytes(reinterpret_cast<const uint8_t *>(CKMem),
5036	Checksum.size());
5037
5038	if (!getStreamer().emitCVFileDirective(FileNo: FileNumber, Filename, Checksum: ChecksumAsBytes,
5039	ChecksumKind: static_cast<uint8_t>(ChecksumKind)))
5040	return Error(L: FileNumberLoc, Msg: "file number already allocated");
5041
5042	return false;
5043	}
5044
5045	bool MasmParser::parseCVFunctionId(int64_t &FunctionId,
5046	StringRef DirectiveName) {
5047	SMLoc Loc;
5048	return parseTokenLoc(Loc) ||
5049	parseIntToken(V&: FunctionId, ErrMsg: "expected function id in '" + DirectiveName +
5050	"' directive") ||
5051	check(P: FunctionId < 0 || FunctionId >= UINT_MAX, Loc,
5052	Msg: "expected function id within range [0, UINT_MAX)");
5053	}
5054
5055	bool MasmParser::parseCVFileId(int64_t &FileNumber, StringRef DirectiveName) {
5056	SMLoc Loc;
5057	return parseTokenLoc(Loc) ||
5058	parseIntToken(V&: FileNumber, ErrMsg: "expected integer in '" + DirectiveName +
5059	"' directive") ||
5060	check(P: FileNumber < 1, Loc, Msg: "file number less than one in '" +
5061	DirectiveName + "' directive") ||
5062	check(P: !getCVContext().isValidFileNumber(FileNumber), Loc,
5063	Msg: "unassigned file number in '" + DirectiveName + "' directive");
5064	}
5065
5066	/// parseDirectiveCVFuncId
5067	/// ::= .cv_func_id FunctionId
5068	///
5069	/// Introduces a function ID that can be used with .cv_loc.
5070	bool MasmParser::parseDirectiveCVFuncId() {
5071	SMLoc FunctionIdLoc = getTok().getLoc();
5072	int64_t FunctionId;
5073
5074	if (parseCVFunctionId(FunctionId, DirectiveName: ".cv_func_id") || parseEOL())
5075	return true;
5076
5077	if (!getStreamer().emitCVFuncIdDirective(FunctionId))
5078	return Error(L: FunctionIdLoc, Msg: "function id already allocated");
5079
5080	return false;
5081	}
5082
5083	/// parseDirectiveCVInlineSiteId
5084	/// ::= .cv_inline_site_id FunctionId
5085	/// "within" IAFunc
5086	/// "inlined_at" IAFile IALine [IACol]
5087	///
5088	/// Introduces a function ID that can be used with .cv_loc. Includes "inlined
5089	/// at" source location information for use in the line table of the caller,
5090	/// whether the caller is a real function or another inlined call site.
5091	bool MasmParser::parseDirectiveCVInlineSiteId() {
5092	SMLoc FunctionIdLoc = getTok().getLoc();
5093	int64_t FunctionId;
5094	int64_t IAFunc;
5095	int64_t IAFile;
5096	int64_t IALine;
5097	int64_t IACol = 0;
5098
5099	// FunctionId
5100	if (parseCVFunctionId(FunctionId, DirectiveName: ".cv_inline_site_id"))
5101	return true;
5102
5103	// "within"
5104	if (check(P: (getLexer().isNot(K: AsmToken::Identifier) ||
5105	getTok().getIdentifier() != "within"),
5106	Msg: "expected 'within' identifier in '.cv_inline_site_id' directive"))
5107	return true;
5108	Lex();
5109
5110	// IAFunc
5111	if (parseCVFunctionId(FunctionId&: IAFunc, DirectiveName: ".cv_inline_site_id"))
5112	return true;
5113
5114	// "inlined_at"
5115	if (check(P: (getLexer().isNot(K: AsmToken::Identifier) ||
5116	getTok().getIdentifier() != "inlined_at"),
5117	Msg: "expected 'inlined_at' identifier in '.cv_inline_site_id' "
5118	"directive") )
5119	return true;
5120	Lex();
5121
5122	// IAFile IALine
5123	if (parseCVFileId(FileNumber&: IAFile, DirectiveName: ".cv_inline_site_id") ||
5124	parseIntToken(V&: IALine, ErrMsg: "expected line number after 'inlined_at'"))
5125	return true;
5126
5127	// [IACol]
5128	if (getLexer().is(K: AsmToken::Integer)) {
5129	IACol = getTok().getIntVal();
5130	Lex();
5131	}
5132
5133	if (parseEOL())
5134	return true;
5135
5136	if (!getStreamer().emitCVInlineSiteIdDirective(FunctionId, IAFunc, IAFile,
5137	IALine, IACol, Loc: FunctionIdLoc))
5138	return Error(L: FunctionIdLoc, Msg: "function id already allocated");
5139
5140	return false;
5141	}
5142
5143	/// parseDirectiveCVLoc
5144	/// ::= .cv_loc FunctionId FileNumber [LineNumber] [ColumnPos] [prologue_end]
5145	/// [is_stmt VALUE]
5146	/// The first number is a file number, must have been previously assigned with
5147	/// a .file directive, the second number is the line number and optionally the
5148	/// third number is a column position (zero if not specified). The remaining
5149	/// optional items are .loc sub-directives.
5150	bool MasmParser::parseDirectiveCVLoc() {
5151	SMLoc DirectiveLoc = getTok().getLoc();
5152	int64_t FunctionId, FileNumber;
5153	if (parseCVFunctionId(FunctionId, DirectiveName: ".cv_loc") ||
5154	parseCVFileId(FileNumber, DirectiveName: ".cv_loc"))
5155	return true;
5156
5157	int64_t LineNumber = 0;
5158	if (getLexer().is(K: AsmToken::Integer)) {
5159	LineNumber = getTok().getIntVal();
5160	if (LineNumber < 0)
5161	return TokError(Msg: "line number less than zero in '.cv_loc' directive");
5162	Lex();
5163	}
5164
5165	int64_t ColumnPos = 0;
5166	if (getLexer().is(K: AsmToken::Integer)) {
5167	ColumnPos = getTok().getIntVal();
5168	if (ColumnPos < 0)
5169	return TokError(Msg: "column position less than zero in '.cv_loc' directive");
5170	Lex();
5171	}
5172
5173	bool PrologueEnd = false;
5174	uint64_t IsStmt = 0;
5175
5176	auto parseOp = [&]() -> bool {
5177	StringRef Name;
5178	SMLoc Loc = getTok().getLoc();
5179	if (parseIdentifier(Res&: Name))
5180	return TokError(Msg: "unexpected token in '.cv_loc' directive");
5181	if (Name == "prologue_end")
5182	PrologueEnd = true;
5183	else if (Name == "is_stmt") {
5184	Loc = getTok().getLoc();
5185	const MCExpr *Value;
5186	if (parseExpression(Res&: Value))
5187	return true;
5188	// The expression must be the constant 0 or 1.
5189	IsStmt = ~0ULL;
5190	if (const auto *MCE = dyn_cast<MCConstantExpr>(Val: Value))
5191	IsStmt = MCE->getValue();
5192
5193	if (IsStmt > 1)
5194	return Error(L: Loc, Msg: "is_stmt value not 0 or 1");
5195	} else {
5196	return Error(L: Loc, Msg: "unknown sub-directive in '.cv_loc' directive");
5197	}
5198	return false;
5199	};
5200
5201	if (parseMany(parseOne: parseOp, hasComma: false /*hasComma*/))
5202	return true;
5203
5204	getStreamer().emitCVLocDirective(FunctionId, FileNo: FileNumber, Line: LineNumber,
5205	Column: ColumnPos, PrologueEnd, IsStmt, FileName: StringRef(),
5206	Loc: DirectiveLoc);
5207	return false;
5208	}
5209
5210	/// parseDirectiveCVLinetable
5211	/// ::= .cv_linetable FunctionId, FnStart, FnEnd
5212	bool MasmParser::parseDirectiveCVLinetable() {
5213	int64_t FunctionId;
5214	StringRef FnStartName, FnEndName;
5215	SMLoc Loc = getTok().getLoc();
5216	if (parseCVFunctionId(FunctionId, DirectiveName: ".cv_linetable") ||
5217	parseToken(T: AsmToken::Comma,
5218	Msg: "unexpected token in '.cv_linetable' directive") ||
5219	parseTokenLoc(Loc) || check(P: parseIdentifier(Res&: FnStartName), Loc,
5220	Msg: "expected identifier in directive") ||
5221	parseToken(T: AsmToken::Comma,
5222	Msg: "unexpected token in '.cv_linetable' directive") ||
5223	parseTokenLoc(Loc) || check(P: parseIdentifier(Res&: FnEndName), Loc,
5224	Msg: "expected identifier in directive"))
5225	return true;
5226
5227	MCSymbol *FnStartSym = getContext().getOrCreateSymbol(Name: FnStartName);
5228	MCSymbol *FnEndSym = getContext().getOrCreateSymbol(Name: FnEndName);
5229
5230	getStreamer().emitCVLinetableDirective(FunctionId, FnStart: FnStartSym, FnEnd: FnEndSym);
5231	return false;
5232	}
5233
5234	/// parseDirectiveCVInlineLinetable
5235	/// ::= .cv_inline_linetable PrimaryFunctionId FileId LineNum FnStart FnEnd
5236	bool MasmParser::parseDirectiveCVInlineLinetable() {
5237	int64_t PrimaryFunctionId, SourceFileId, SourceLineNum;
5238	StringRef FnStartName, FnEndName;
5239	SMLoc Loc = getTok().getLoc();
5240	if (parseCVFunctionId(FunctionId&: PrimaryFunctionId, DirectiveName: ".cv_inline_linetable") ||
5241	parseTokenLoc(Loc) ||
5242	parseIntToken(
5243	V&: SourceFileId,
5244	ErrMsg: "expected SourceField in '.cv_inline_linetable' directive") ||
5245	check(P: SourceFileId <= 0, Loc,
5246	Msg: "File id less than zero in '.cv_inline_linetable' directive") ||
5247	parseTokenLoc(Loc) ||
5248	parseIntToken(
5249	V&: SourceLineNum,
5250	ErrMsg: "expected SourceLineNum in '.cv_inline_linetable' directive") ||
5251	check(P: SourceLineNum < 0, Loc,
5252	Msg: "Line number less than zero in '.cv_inline_linetable' directive") ||
5253	parseTokenLoc(Loc) || check(P: parseIdentifier(Res&: FnStartName), Loc,
5254	Msg: "expected identifier in directive") ||
5255	parseTokenLoc(Loc) || check(P: parseIdentifier(Res&: FnEndName), Loc,
5256	Msg: "expected identifier in directive"))
5257	return true;
5258
5259	if (parseEOL())
5260	return true;
5261
5262	MCSymbol *FnStartSym = getContext().getOrCreateSymbol(Name: FnStartName);
5263	MCSymbol *FnEndSym = getContext().getOrCreateSymbol(Name: FnEndName);
5264	getStreamer().emitCVInlineLinetableDirective(PrimaryFunctionId, SourceFileId,
5265	SourceLineNum, FnStartSym,
5266	FnEndSym);
5267	return false;
5268	}
5269
5270	void MasmParser::initializeCVDefRangeTypeMap() {
5271	CVDefRangeTypeMap["reg"] = CVDR_DEFRANGE_REGISTER;
5272	CVDefRangeTypeMap["frame_ptr_rel"] = CVDR_DEFRANGE_FRAMEPOINTER_REL;
5273	CVDefRangeTypeMap["subfield_reg"] = CVDR_DEFRANGE_SUBFIELD_REGISTER;
5274	CVDefRangeTypeMap["reg_rel"] = CVDR_DEFRANGE_REGISTER_REL;
5275	}
5276
5277	/// parseDirectiveCVDefRange
5278	/// ::= .cv_def_range RangeStart RangeEnd (GapStart GapEnd)*, bytes*
5279	bool MasmParser::parseDirectiveCVDefRange() {
5280	SMLoc Loc;
5281	std::vector<std::pair<const MCSymbol *, const MCSymbol *>> Ranges;
5282	while (getLexer().is(K: AsmToken::Identifier)) {
5283	Loc = getLexer().getLoc();
5284	StringRef GapStartName;
5285	if (parseIdentifier(Res&: GapStartName))
5286	return Error(L: Loc, Msg: "expected identifier in directive");
5287	MCSymbol *GapStartSym = getContext().getOrCreateSymbol(Name: GapStartName);
5288
5289	Loc = getLexer().getLoc();
5290	StringRef GapEndName;
5291	if (parseIdentifier(Res&: GapEndName))
5292	return Error(L: Loc, Msg: "expected identifier in directive");
5293	MCSymbol *GapEndSym = getContext().getOrCreateSymbol(Name: GapEndName);
5294
5295	Ranges.push_back(x: {GapStartSym, GapEndSym});
5296	}
5297
5298	StringRef CVDefRangeTypeStr;
5299	if (parseToken(
5300	T: AsmToken::Comma,
5301	Msg: "expected comma before def_range type in .cv_def_range directive") ||
5302	parseIdentifier(Res&: CVDefRangeTypeStr))
5303	return Error(L: Loc, Msg: "expected def_range type in directive");
5304
5305	StringMap<CVDefRangeType>::const_iterator CVTypeIt =
5306	CVDefRangeTypeMap.find(Key: CVDefRangeTypeStr);
5307	CVDefRangeType CVDRType = (CVTypeIt == CVDefRangeTypeMap.end())
5308	? CVDR_DEFRANGE
5309	: CVTypeIt->getValue();
5310	switch (CVDRType) {
5311	case CVDR_DEFRANGE_REGISTER: {
5312	int64_t DRRegister;
5313	if (parseToken(T: AsmToken::Comma, Msg: "expected comma before register number in "
5314	".cv_def_range directive") ||
5315	parseAbsoluteExpression(Res&: DRRegister))
5316	return Error(L: Loc, Msg: "expected register number");
5317
5318	codeview::DefRangeRegisterHeader DRHdr;
5319	DRHdr.Register = DRRegister;
5320	DRHdr.MayHaveNoName = 0;
5321	getStreamer().emitCVDefRangeDirective(Ranges, DRHdr);
5322	break;
5323	}
5324	case CVDR_DEFRANGE_FRAMEPOINTER_REL: {
5325	int64_t DROffset;
5326	if (parseToken(T: AsmToken::Comma,
5327	Msg: "expected comma before offset in .cv_def_range directive") ||
5328	parseAbsoluteExpression(Res&: DROffset))
5329	return Error(L: Loc, Msg: "expected offset value");
5330
5331	codeview::DefRangeFramePointerRelHeader DRHdr;
5332	DRHdr.Offset = DROffset;
5333	getStreamer().emitCVDefRangeDirective(Ranges, DRHdr);
5334	break;
5335	}
5336	case CVDR_DEFRANGE_SUBFIELD_REGISTER: {
5337	int64_t DRRegister;
5338	int64_t DROffsetInParent;
5339	if (parseToken(T: AsmToken::Comma, Msg: "expected comma before register number in "
5340	".cv_def_range directive") ||
5341	parseAbsoluteExpression(Res&: DRRegister))
5342	return Error(L: Loc, Msg: "expected register number");
5343	if (parseToken(T: AsmToken::Comma,
5344	Msg: "expected comma before offset in .cv_def_range directive") ||
5345	parseAbsoluteExpression(Res&: DROffsetInParent))
5346	return Error(L: Loc, Msg: "expected offset value");
5347
5348	codeview::DefRangeSubfieldRegisterHeader DRHdr;
5349	DRHdr.Register = DRRegister;
5350	DRHdr.MayHaveNoName = 0;
5351	DRHdr.OffsetInParent = DROffsetInParent;
5352	getStreamer().emitCVDefRangeDirective(Ranges, DRHdr);
5353	break;
5354	}
5355	case CVDR_DEFRANGE_REGISTER_REL: {
5356	int64_t DRRegister;
5357	int64_t DRFlags;
5358	int64_t DRBasePointerOffset;
5359	if (parseToken(T: AsmToken::Comma, Msg: "expected comma before register number in "
5360	".cv_def_range directive") ||
5361	parseAbsoluteExpression(Res&: DRRegister))
5362	return Error(L: Loc, Msg: "expected register value");
5363	if (parseToken(
5364	T: AsmToken::Comma,
5365	Msg: "expected comma before flag value in .cv_def_range directive") ||
5366	parseAbsoluteExpression(Res&: DRFlags))
5367	return Error(L: Loc, Msg: "expected flag value");
5368	if (parseToken(T: AsmToken::Comma, Msg: "expected comma before base pointer offset "
5369	"in .cv_def_range directive") ||
5370	parseAbsoluteExpression(Res&: DRBasePointerOffset))
5371	return Error(L: Loc, Msg: "expected base pointer offset value");
5372
5373	codeview::DefRangeRegisterRelHeader DRHdr;
5374	DRHdr.Register = DRRegister;
5375	DRHdr.Flags = DRFlags;
5376	DRHdr.BasePointerOffset = DRBasePointerOffset;
5377	getStreamer().emitCVDefRangeDirective(Ranges, DRHdr);
5378	break;
5379	}
5380	default:
5381	return Error(L: Loc, Msg: "unexpected def_range type in .cv_def_range directive");
5382	}
5383	return true;
5384	}
5385
5386	/// parseDirectiveCVString
5387	/// ::= .cv_stringtable "string"
5388	bool MasmParser::parseDirectiveCVString() {
5389	std::string Data;
5390	if (checkForValidSection() || parseEscapedString(Data))
5391	return addErrorSuffix(Suffix: " in '.cv_string' directive");
5392
5393	// Put the string in the table and emit the offset.
5394	std::pair<StringRef, unsigned> Insertion =
5395	getCVContext().addToStringTable(S: Data);
5396	getStreamer().emitIntValue(Value: Insertion.second, Size: 4);
5397	return false;
5398	}
5399
5400	/// parseDirectiveCVStringTable
5401	/// ::= .cv_stringtable
5402	bool MasmParser::parseDirectiveCVStringTable() {
5403	getStreamer().emitCVStringTableDirective();
5404	return false;
5405	}
5406
5407	/// parseDirectiveCVFileChecksums
5408	/// ::= .cv_filechecksums
5409	bool MasmParser::parseDirectiveCVFileChecksums() {
5410	getStreamer().emitCVFileChecksumsDirective();
5411	return false;
5412	}
5413
5414	/// parseDirectiveCVFileChecksumOffset
5415	/// ::= .cv_filechecksumoffset fileno
5416	bool MasmParser::parseDirectiveCVFileChecksumOffset() {
5417	int64_t FileNo;
5418	if (parseIntToken(V&: FileNo, ErrMsg: "expected identifier in directive"))
5419	return true;
5420	if (parseEOL())
5421	return true;
5422	getStreamer().emitCVFileChecksumOffsetDirective(FileNo);
5423	return false;
5424	}
5425
5426	/// parseDirectiveCVFPOData
5427	/// ::= .cv_fpo_data procsym
5428	bool MasmParser::parseDirectiveCVFPOData() {
5429	SMLoc DirLoc = getLexer().getLoc();
5430	StringRef ProcName;
5431	if (parseIdentifier(Res&: ProcName))
5432	return TokError(Msg: "expected symbol name");
5433	if (parseEOL(ErrMsg: "unexpected tokens"))
5434	return addErrorSuffix(Suffix: " in '.cv_fpo_data' directive");
5435	MCSymbol *ProcSym = getContext().getOrCreateSymbol(Name: ProcName);
5436	getStreamer().emitCVFPOData(ProcSym, Loc: DirLoc);
5437	return false;
5438	}
5439
5440	/// parseDirectiveCFISections
5441	/// ::= .cfi_sections section [, section]
5442	bool MasmParser::parseDirectiveCFISections() {
5443	StringRef Name;
5444	bool EH = false;
5445	bool Debug = false;
5446
5447	if (parseIdentifier(Res&: Name))
5448	return TokError(Msg: "Expected an identifier");
5449
5450	if (Name == ".eh_frame")
5451	EH = true;
5452	else if (Name == ".debug_frame")
5453	Debug = true;
5454
5455	if (getLexer().is(K: AsmToken::Comma)) {
5456	Lex();
5457
5458	if (parseIdentifier(Res&: Name))
5459	return TokError(Msg: "Expected an identifier");
5460
5461	if (Name == ".eh_frame")
5462	EH = true;
5463	else if (Name == ".debug_frame")
5464	Debug = true;
5465	}
5466
5467	getStreamer().emitCFISections(EH, Debug);
5468	return false;
5469	}
5470
5471	/// parseDirectiveCFIStartProc
5472	/// ::= .cfi_startproc [simple]
5473	bool MasmParser::parseDirectiveCFIStartProc() {
5474	StringRef Simple;
5475	if (!parseOptionalToken(T: AsmToken::EndOfStatement)) {
5476	if (check(P: parseIdentifier(Res&: Simple) || Simple != "simple",
5477	Msg: "unexpected token") ||
5478	parseEOL())
5479	return addErrorSuffix(Suffix: " in '.cfi_startproc' directive");
5480	}
5481
5482	// TODO(kristina): Deal with a corner case of incorrect diagnostic context
5483	// being produced if this directive is emitted as part of preprocessor macro
5484	// expansion which can *ONLY* happen if Clang's cc1as is the API consumer.
5485	// Tools like llvm-mc on the other hand are not affected by it, and report
5486	// correct context information.
5487	getStreamer().emitCFIStartProc(IsSimple: !Simple.empty(), Loc: Lexer.getLoc());
5488	return false;
5489	}
5490
5491	/// parseDirectiveCFIEndProc
5492	/// ::= .cfi_endproc
5493	bool MasmParser::parseDirectiveCFIEndProc() {
5494	getStreamer().emitCFIEndProc();
5495	return false;
5496	}
5497
5498	/// parse register name or number.
5499	bool MasmParser::parseRegisterOrRegisterNumber(int64_t &Register,
5500	SMLoc DirectiveLoc) {
5501	MCRegister RegNo;
5502
5503	if (getLexer().isNot(K: AsmToken::Integer)) {
5504	if (getTargetParser().parseRegister(Reg&: RegNo, StartLoc&: DirectiveLoc, EndLoc&: DirectiveLoc))
5505	return true;
5506	Register = getContext().getRegisterInfo()->getDwarfRegNum(RegNum: RegNo, isEH: true);
5507	} else
5508	return parseAbsoluteExpression(Res&: Register);
5509
5510	return false;
5511	}
5512
5513	/// parseDirectiveCFIDefCfa
5514	/// ::= .cfi_def_cfa register, offset
5515	bool MasmParser::parseDirectiveCFIDefCfa(SMLoc DirectiveLoc) {
5516	int64_t Register = 0, Offset = 0;
5517	if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) ||
5518	parseToken(T: AsmToken::Comma, Msg: "unexpected token in directive") ||
5519	parseAbsoluteExpression(Res&: Offset))
5520	return true;
5521
5522	getStreamer().emitCFIDefCfa(Register, Offset);
5523	return false;
5524	}
5525
5526	/// parseDirectiveCFIDefCfaOffset
5527	/// ::= .cfi_def_cfa_offset offset
5528	bool MasmParser::parseDirectiveCFIDefCfaOffset(SMLoc DirectiveLoc) {
5529	int64_t Offset = 0;
5530	if (parseAbsoluteExpression(Res&: Offset))
5531	return true;
5532
5533	getStreamer().emitCFIDefCfaOffset(Offset, Loc: DirectiveLoc);
5534	return false;
5535	}
5536
5537	/// parseDirectiveCFIRegister
5538	/// ::= .cfi_register register, register
5539	bool MasmParser::parseDirectiveCFIRegister(SMLoc DirectiveLoc) {
5540	int64_t Register1 = 0, Register2 = 0;
5541	if (parseRegisterOrRegisterNumber(Register&: Register1, DirectiveLoc) ||
5542	parseToken(T: AsmToken::Comma, Msg: "unexpected token in directive") ||
5543	parseRegisterOrRegisterNumber(Register&: Register2, DirectiveLoc))
5544	return true;
5545
5546	getStreamer().emitCFIRegister(Register1, Register2, Loc: DirectiveLoc);
5547	return false;
5548	}
5549
5550	/// parseDirectiveCFIWindowSave
5551	/// ::= .cfi_window_save
5552	bool MasmParser::parseDirectiveCFIWindowSave(SMLoc DirectiveLoc) {
5553	getStreamer().emitCFIWindowSave(Loc: DirectiveLoc);
5554	return false;
5555	}
5556
5557	/// parseDirectiveCFIAdjustCfaOffset
5558	/// ::= .cfi_adjust_cfa_offset adjustment
5559	bool MasmParser::parseDirectiveCFIAdjustCfaOffset(SMLoc DirectiveLoc) {
5560	int64_t Adjustment = 0;
5561	if (parseAbsoluteExpression(Res&: Adjustment))
5562	return true;
5563
5564	getStreamer().emitCFIAdjustCfaOffset(Adjustment, Loc: DirectiveLoc);
5565	return false;
5566	}
5567
5568	/// parseDirectiveCFIDefCfaRegister
5569	/// ::= .cfi_def_cfa_register register
5570	bool MasmParser::parseDirectiveCFIDefCfaRegister(SMLoc DirectiveLoc) {
5571	int64_t Register = 0;
5572	if (parseRegisterOrRegisterNumber(Register, DirectiveLoc))
5573	return true;
5574
5575	getStreamer().emitCFIDefCfaRegister(Register);
5576	return false;
5577	}
5578
5579	/// parseDirectiveCFIOffset
5580	/// ::= .cfi_offset register, offset
5581	bool MasmParser::parseDirectiveCFIOffset(SMLoc DirectiveLoc) {
5582	int64_t Register = 0;
5583	int64_t Offset = 0;
5584
5585	if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) ||
5586	parseToken(T: AsmToken::Comma, Msg: "unexpected token in directive") ||
5587	parseAbsoluteExpression(Res&: Offset))
5588	return true;
5589
5590	getStreamer().emitCFIOffset(Register, Offset);
5591	return false;
5592	}
5593
5594	/// parseDirectiveCFIRelOffset
5595	/// ::= .cfi_rel_offset register, offset
5596	bool MasmParser::parseDirectiveCFIRelOffset(SMLoc DirectiveLoc) {
5597	int64_t Register = 0, Offset = 0;
5598
5599	if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) ||
5600	parseToken(T: AsmToken::Comma, Msg: "unexpected token in directive") ||
5601	parseAbsoluteExpression(Res&: Offset))
5602	return true;
5603
5604	getStreamer().emitCFIRelOffset(Register, Offset, Loc: DirectiveLoc);
5605	return false;
5606	}
5607
5608	static bool isValidEncoding(int64_t Encoding) {
5609	if (Encoding & ~0xff)
5610	return false;
5611
5612	if (Encoding == dwarf::DW_EH_PE_omit)
5613	return true;
5614
5615	const unsigned Format = Encoding & 0xf;
5616	if (Format != dwarf::DW_EH_PE_absptr && Format != dwarf::DW_EH_PE_udata2 &&
5617	Format != dwarf::DW_EH_PE_udata4 && Format != dwarf::DW_EH_PE_udata8 &&
5618	Format != dwarf::DW_EH_PE_sdata2 && Format != dwarf::DW_EH_PE_sdata4 &&
5619	Format != dwarf::DW_EH_PE_sdata8 && Format != dwarf::DW_EH_PE_signed)
5620	return false;
5621
5622	const unsigned Application = Encoding & 0x70;
5623	if (Application != dwarf::DW_EH_PE_absptr &&
5624	Application != dwarf::DW_EH_PE_pcrel)
5625	return false;
5626
5627	return true;
5628	}
5629
5630	/// parseDirectiveCFIPersonalityOrLsda
5631	/// IsPersonality true for cfi_personality, false for cfi_lsda
5632	/// ::= .cfi_personality encoding, [symbol_name]
5633	/// ::= .cfi_lsda encoding, [symbol_name]
5634	bool MasmParser::parseDirectiveCFIPersonalityOrLsda(bool IsPersonality) {
5635	int64_t Encoding = 0;
5636	if (parseAbsoluteExpression(Res&: Encoding))
5637	return true;
5638	if (Encoding == dwarf::DW_EH_PE_omit)
5639	return false;
5640
5641	StringRef Name;
5642	if (check(P: !isValidEncoding(Encoding), Msg: "unsupported encoding.") ||
5643	parseToken(T: AsmToken::Comma, Msg: "unexpected token in directive") ||
5644	check(P: parseIdentifier(Res&: Name), Msg: "expected identifier in directive"))
5645	return true;
5646
5647	MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
5648
5649	if (IsPersonality)
5650	getStreamer().emitCFIPersonality(Sym, Encoding);
5651	else
5652	getStreamer().emitCFILsda(Sym, Encoding);
5653	return false;
5654	}
5655
5656	/// parseDirectiveCFIRememberState
5657	/// ::= .cfi_remember_state
5658	bool MasmParser::parseDirectiveCFIRememberState(SMLoc DirectiveLoc) {
5659	getStreamer().emitCFIRememberState(Loc: DirectiveLoc);
5660	return false;
5661	}
5662
5663	/// parseDirectiveCFIRestoreState
5664	/// ::= .cfi_remember_state
5665	bool MasmParser::parseDirectiveCFIRestoreState(SMLoc DirectiveLoc) {
5666	getStreamer().emitCFIRestoreState(Loc: DirectiveLoc);
5667	return false;
5668	}
5669
5670	/// parseDirectiveCFISameValue
5671	/// ::= .cfi_same_value register
5672	bool MasmParser::parseDirectiveCFISameValue(SMLoc DirectiveLoc) {
5673	int64_t Register = 0;
5674
5675	if (parseRegisterOrRegisterNumber(Register, DirectiveLoc))
5676	return true;
5677
5678	getStreamer().emitCFISameValue(Register, Loc: DirectiveLoc);
5679	return false;
5680	}
5681
5682	/// parseDirectiveCFIRestore
5683	/// ::= .cfi_restore register
5684	bool MasmParser::parseDirectiveCFIRestore(SMLoc DirectiveLoc) {
5685	int64_t Register = 0;
5686	if (parseRegisterOrRegisterNumber(Register, DirectiveLoc))
5687	return true;
5688
5689	getStreamer().emitCFIRestore(Register);
5690	return false;
5691	}
5692
5693	/// parseDirectiveCFIEscape
5694	/// ::= .cfi_escape expression[,...]
5695	bool MasmParser::parseDirectiveCFIEscape(SMLoc DirectiveLoc) {
5696	std::string Values;
5697	int64_t CurrValue;
5698	if (parseAbsoluteExpression(Res&: CurrValue))
5699	return true;
5700
5701	Values.push_back(c: (uint8_t)CurrValue);
5702
5703	while (getLexer().is(K: AsmToken::Comma)) {
5704	Lex();
5705
5706	if (parseAbsoluteExpression(Res&: CurrValue))
5707	return true;
5708
5709	Values.push_back(c: (uint8_t)CurrValue);
5710	}
5711
5712	getStreamer().emitCFIEscape(Values, Loc: DirectiveLoc);
5713	return false;
5714	}
5715
5716	/// parseDirectiveCFIReturnColumn
5717	/// ::= .cfi_return_column register
5718	bool MasmParser::parseDirectiveCFIReturnColumn(SMLoc DirectiveLoc) {
5719	int64_t Register = 0;
5720	if (parseRegisterOrRegisterNumber(Register, DirectiveLoc))
5721	return true;
5722	getStreamer().emitCFIReturnColumn(Register);
5723	return false;
5724	}
5725
5726	/// parseDirectiveCFISignalFrame
5727	/// ::= .cfi_signal_frame
5728	bool MasmParser::parseDirectiveCFISignalFrame() {
5729	if (parseEOL())
5730	return true;
5731
5732	getStreamer().emitCFISignalFrame();
5733	return false;
5734	}
5735
5736	/// parseDirectiveCFIUndefined
5737	/// ::= .cfi_undefined register
5738	bool MasmParser::parseDirectiveCFIUndefined(SMLoc DirectiveLoc) {
5739	int64_t Register = 0;
5740
5741	if (parseRegisterOrRegisterNumber(Register, DirectiveLoc))
5742	return true;
5743
5744	getStreamer().emitCFIUndefined(Register);
5745	return false;
5746	}
5747
5748	/// parseDirectiveMacro
5749	/// ::= name macro [parameters]
5750	/// ["LOCAL" identifiers]
5751	/// parameters ::= parameter [, parameter]*
5752	/// parameter ::= name ":" qualifier
5753	/// qualifier ::= "req" | "vararg" | "=" macro_argument
5754	bool MasmParser::parseDirectiveMacro(StringRef Name, SMLoc NameLoc) {
5755	MCAsmMacroParameters Parameters;
5756	while (getLexer().isNot(K: AsmToken::EndOfStatement)) {
5757	if (!Parameters.empty() && Parameters.back().Vararg)
5758	return Error(L: Lexer.getLoc(),
5759	Msg: "Vararg parameter '" + Parameters.back().Name +
5760	"' should be last in the list of parameters");
5761
5762	MCAsmMacroParameter Parameter;
5763	if (parseIdentifier(Res&: Parameter.Name))
5764	return TokError(Msg: "expected identifier in 'macro' directive");
5765
5766	// Emit an error if two (or more) named parameters share the same name.
5767	for (const MCAsmMacroParameter& CurrParam : Parameters)
5768	if (CurrParam.Name.equals_insensitive(RHS: Parameter.Name))
5769	return TokError(Msg: "macro '" + Name + "' has multiple parameters"
5770	" named '" + Parameter.Name + "'");
5771
5772	if (Lexer.is(K: AsmToken::Colon)) {
5773	Lex(); // consume ':'
5774
5775	if (parseOptionalToken(T: AsmToken::Equal)) {
5776	// Default value
5777	SMLoc ParamLoc;
5778
5779	ParamLoc = Lexer.getLoc();
5780	if (parseMacroArgument(MP: nullptr, MA&: Parameter.Value))
5781	return true;
5782	} else {
5783	SMLoc QualLoc;
5784	StringRef Qualifier;
5785
5786	QualLoc = Lexer.getLoc();
5787	if (parseIdentifier(Res&: Qualifier))
5788	return Error(L: QualLoc, Msg: "missing parameter qualifier for "
5789	"'" +
5790	Parameter.Name + "' in macro '" + Name +
5791	"'");
5792
5793	if (Qualifier.equals_insensitive(RHS: "req"))
5794	Parameter.Required = true;
5795	else if (Qualifier.equals_insensitive(RHS: "vararg"))
5796	Parameter.Vararg = true;
5797	else
5798	return Error(L: QualLoc,
5799	Msg: Qualifier + " is not a valid parameter qualifier for '" +
5800	Parameter.Name + "' in macro '" + Name + "'");
5801	}
5802	}
5803
5804	Parameters.push_back(x: std::move(Parameter));
5805
5806	if (getLexer().is(K: AsmToken::Comma))
5807	Lex();
5808	}
5809
5810	// Eat just the end of statement.
5811	Lexer.Lex();
5812
5813	std::vector<std::string> Locals;
5814	if (getTok().is(K: AsmToken::Identifier) &&
5815	getTok().getIdentifier().equals_insensitive(RHS: "local")) {
5816	Lex(); // Eat the LOCAL directive.
5817
5818	StringRef ID;
5819	while (true) {
5820	if (parseIdentifier(Res&: ID))
5821	return true;
5822	Locals.push_back(x: ID.lower());
5823
5824	// If we see a comma, continue (and allow line continuation).
5825	if (!parseOptionalToken(T: AsmToken::Comma))
5826	break;
5827	parseOptionalToken(T: AsmToken::EndOfStatement);
5828	}
5829	}
5830
5831	// Consuming deferred text, so use Lexer.Lex to ignore Lexing Errors.
5832	AsmToken EndToken, StartToken = getTok();
5833	unsigned MacroDepth = 0;
5834	bool IsMacroFunction = false;
5835	// Lex the macro definition.
5836	while (true) {
5837	// Ignore Lexing errors in macros.
5838	while (Lexer.is(K: AsmToken::Error)) {
5839	Lexer.Lex();
5840	}
5841
5842	// Check whether we have reached the end of the file.
5843	if (getLexer().is(K: AsmToken::Eof))
5844	return Error(L: NameLoc, Msg: "no matching 'endm' in definition");
5845
5846	// Otherwise, check whether we have reached the 'endm'... and determine if
5847	// this is a macro function.
5848	if (getLexer().is(K: AsmToken::Identifier)) {
5849	if (getTok().getIdentifier().equals_insensitive(RHS: "endm")) {
5850	if (MacroDepth == 0) { // Outermost macro.
5851	EndToken = getTok();
5852	Lexer.Lex();
5853	if (getLexer().isNot(K: AsmToken::EndOfStatement))
5854	return TokError(Msg: "unexpected token in '" + EndToken.getIdentifier() +
5855	"' directive");
5856	break;
5857	} else {
5858	// Otherwise we just found the end of an inner macro.
5859	--MacroDepth;
5860	}
5861	} else if (getTok().getIdentifier().equals_insensitive(RHS: "exitm")) {
5862	if (MacroDepth == 0 && peekTok().isNot(K: AsmToken::EndOfStatement)) {
5863	IsMacroFunction = true;
5864	}
5865	} else if (isMacroLikeDirective()) {
5866	// We allow nested macros. Those aren't instantiated until the
5867	// outermost macro is expanded so just ignore them for now.
5868	++MacroDepth;
5869	}
5870	}
5871
5872	// Otherwise, scan til the end of the statement.
5873	eatToEndOfStatement();
5874	}
5875
5876	if (getContext().lookupMacro(Name: Name.lower())) {
5877	return Error(L: NameLoc, Msg: "macro '" + Name + "' is already defined");
5878	}
5879
5880	const char *BodyStart = StartToken.getLoc().getPointer();
5881	const char *BodyEnd = EndToken.getLoc().getPointer();
5882	StringRef Body = StringRef(BodyStart, BodyEnd - BodyStart);
5883	MCAsmMacro Macro(Name, Body, std::move(Parameters), std::move(Locals),
5884	IsMacroFunction);
5885	DEBUG_WITH_TYPE("asm-macros", dbgs() << "Defining new macro:\n";
5886	Macro.dump());
5887	getContext().defineMacro(Name: Name.lower(), Macro: std::move(Macro));
5888	return false;
5889	}
5890
5891	/// parseDirectiveExitMacro
5892	/// ::= "exitm" [textitem]
5893	bool MasmParser::parseDirectiveExitMacro(SMLoc DirectiveLoc,
5894	StringRef Directive,
5895	std::string &Value) {
5896	SMLoc EndLoc = getTok().getLoc();
5897	if (getTok().isNot(K: AsmToken::EndOfStatement) && parseTextItem(Data&: Value))
5898	return Error(L: EndLoc,
5899	Msg: "unable to parse text item in '" + Directive + "' directive");
5900	eatToEndOfStatement();
5901
5902	if (!isInsideMacroInstantiation())
5903	return TokError(Msg: "unexpected '" + Directive + "' in file, "
5904	"no current macro definition");
5905
5906	// Exit all conditionals that are active in the current macro.
5907	while (TheCondStack.size() != ActiveMacros.back()->CondStackDepth) {
5908	TheCondState = TheCondStack.back();
5909	TheCondStack.pop_back();
5910	}
5911
5912	handleMacroExit();
5913	return false;
5914	}
5915
5916	/// parseDirectiveEndMacro
5917	/// ::= endm
5918	bool MasmParser::parseDirectiveEndMacro(StringRef Directive) {
5919	if (getLexer().isNot(K: AsmToken::EndOfStatement))
5920	return TokError(Msg: "unexpected token in '" + Directive + "' directive");
5921
5922	// If we are inside a macro instantiation, terminate the current
5923	// instantiation.
5924	if (isInsideMacroInstantiation()) {
5925	handleMacroExit();
5926	return false;
5927	}
5928
5929	// Otherwise, this .endmacro is a stray entry in the file; well formed
5930	// .endmacro directives are handled during the macro definition parsing.
5931	return TokError(Msg: "unexpected '" + Directive + "' in file, "
5932	"no current macro definition");
5933	}
5934
5935	/// parseDirectivePurgeMacro
5936	/// ::= purge identifier ( , identifier )*
5937	bool MasmParser::parseDirectivePurgeMacro(SMLoc DirectiveLoc) {
5938	StringRef Name;
5939	while (true) {
5940	SMLoc NameLoc;
5941	if (parseTokenLoc(Loc&: NameLoc) ||
5942	check(P: parseIdentifier(Res&: Name), Loc: NameLoc,
5943	Msg: "expected identifier in 'purge' directive"))
5944	return true;
5945
5946	DEBUG_WITH_TYPE("asm-macros", dbgs()
5947	<< "Un-defining macro: " << Name << "\n");
5948	if (!getContext().lookupMacro(Name: Name.lower()))
5949	return Error(L: NameLoc, Msg: "macro '" + Name + "' is not defined");
5950	getContext().undefineMacro(Name: Name.lower());
5951
5952	if (!parseOptionalToken(T: AsmToken::Comma))
5953	break;
5954	parseOptionalToken(T: AsmToken::EndOfStatement);
5955	}
5956
5957	return false;
5958	}
5959
5960	bool MasmParser::parseDirectiveExtern() {
5961	// .extern is the default - but we still need to take any provided type info.
5962	auto parseOp = [&]() -> bool {
5963	StringRef Name;
5964	SMLoc NameLoc = getTok().getLoc();
5965	if (parseIdentifier(Res&: Name))
5966	return Error(L: NameLoc, Msg: "expected name");
5967	if (parseToken(T: AsmToken::Colon))
5968	return true;
5969
5970	StringRef TypeName;
5971	SMLoc TypeLoc = getTok().getLoc();
5972	if (parseIdentifier(Res&: TypeName))
5973	return Error(L: TypeLoc, Msg: "expected type");
5974	if (!TypeName.equals_insensitive(RHS: "proc")) {
5975	AsmTypeInfo Type;
5976	if (lookUpType(Name: TypeName, Info&: Type))
5977	return Error(L: TypeLoc, Msg: "unrecognized type");
5978	KnownType[Name.lower()] = Type;
5979	}
5980
5981	MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
5982	Sym->setExternal(true);
5983	getStreamer().emitSymbolAttribute(Symbol: Sym, Attribute: MCSA_Extern);
5984
5985	return false;
5986	};
5987
5988	if (parseMany(parseOne: parseOp))
5989	return addErrorSuffix(Suffix: " in directive 'extern'");
5990	return false;
5991	}
5992
5993	/// parseDirectiveSymbolAttribute
5994	/// ::= { ".globl", ".weak", ... } [ identifier ( , identifier )* ]
5995	bool MasmParser::parseDirectiveSymbolAttribute(MCSymbolAttr Attr) {
5996	auto parseOp = [&]() -> bool {
5997	StringRef Name;
5998	SMLoc Loc = getTok().getLoc();
5999	if (parseIdentifier(Res&: Name))
6000	return Error(L: Loc, Msg: "expected identifier");
6001	MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
6002
6003	// Assembler local symbols don't make any sense here. Complain loudly.
6004	if (Sym->isTemporary())
6005	return Error(L: Loc, Msg: "non-local symbol required");
6006
6007	if (!getStreamer().emitSymbolAttribute(Symbol: Sym, Attribute: Attr))
6008	return Error(L: Loc, Msg: "unable to emit symbol attribute");
6009	return false;
6010	};
6011
6012	if (parseMany(parseOne: parseOp))
6013	return addErrorSuffix(Suffix: " in directive");
6014	return false;
6015	}
6016
6017	/// parseDirectiveComm
6018	/// ::= ( .comm | .lcomm ) identifier , size_expression [ , align_expression ]
6019	bool MasmParser::parseDirectiveComm(bool IsLocal) {
6020	if (checkForValidSection())
6021	return true;
6022
6023	SMLoc IDLoc = getLexer().getLoc();
6024	StringRef Name;
6025	if (parseIdentifier(Res&: Name))
6026	return TokError(Msg: "expected identifier in directive");
6027
6028	// Handle the identifier as the key symbol.
6029	MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
6030
6031	if (getLexer().isNot(K: AsmToken::Comma))
6032	return TokError(Msg: "unexpected token in directive");
6033	Lex();
6034
6035	int64_t Size;
6036	SMLoc SizeLoc = getLexer().getLoc();
6037	if (parseAbsoluteExpression(Res&: Size))
6038	return true;
6039
6040	int64_t Pow2Alignment = 0;
6041	SMLoc Pow2AlignmentLoc;
6042	if (getLexer().is(K: AsmToken::Comma)) {
6043	Lex();
6044	Pow2AlignmentLoc = getLexer().getLoc();
6045	if (parseAbsoluteExpression(Res&: Pow2Alignment))
6046	return true;
6047
6048	LCOMM::LCOMMType LCOMM = Lexer.getMAI().getLCOMMDirectiveAlignmentType();
6049	if (IsLocal && LCOMM == LCOMM::NoAlignment)
6050	return Error(L: Pow2AlignmentLoc, Msg: "alignment not supported on this target");
6051
6052	// If this target takes alignments in bytes (not log) validate and convert.
6053	if ((!IsLocal && Lexer.getMAI().getCOMMDirectiveAlignmentIsInBytes()) ||
6054	(IsLocal && LCOMM == LCOMM::ByteAlignment)) {
6055	if (!isPowerOf2_64(Value: Pow2Alignment))
6056	return Error(L: Pow2AlignmentLoc, Msg: "alignment must be a power of 2");
6057	Pow2Alignment = Log2_64(Value: Pow2Alignment);
6058	}
6059	}
6060
6061	if (parseEOL())
6062	return true;
6063
6064	// NOTE: a size of zero for a .comm should create a undefined symbol
6065	// but a size of .lcomm creates a bss symbol of size zero.
6066	if (Size < 0)
6067	return Error(L: SizeLoc, Msg: "invalid '.comm' or '.lcomm' directive size, can't "
6068	"be less than zero");
6069
6070	// NOTE: The alignment in the directive is a power of 2 value, the assembler
6071	// may internally end up wanting an alignment in bytes.
6072	// FIXME: Diagnose overflow.
6073	if (Pow2Alignment < 0)
6074	return Error(L: Pow2AlignmentLoc, Msg: "invalid '.comm' or '.lcomm' directive "
6075	"alignment, can't be less than zero");
6076
6077	Sym->redefineIfPossible();
6078	if (!Sym->isUndefined())
6079	return Error(L: IDLoc, Msg: "invalid symbol redefinition");
6080
6081	// Create the Symbol as a common or local common with Size and Pow2Alignment.
6082	if (IsLocal) {
6083	getStreamer().emitLocalCommonSymbol(Symbol: Sym, Size,
6084	ByteAlignment: Align(1ULL << Pow2Alignment));
6085	return false;
6086	}
6087
6088	getStreamer().emitCommonSymbol(Symbol: Sym, Size, ByteAlignment: Align(1ULL << Pow2Alignment));
6089	return false;
6090	}
6091
6092	/// parseDirectiveComment
6093	/// ::= comment delimiter [[text]]
6094	/// [[text]]
6095	/// [[text]] delimiter [[text]]
6096	bool MasmParser::parseDirectiveComment(SMLoc DirectiveLoc) {
6097	std::string FirstLine = parseStringTo(EndTok: AsmToken::EndOfStatement);
6098	size_t DelimiterEnd = FirstLine.find_first_of(s: "\b\t\v\f\r\x1A ");
6099	assert(DelimiterEnd != std::string::npos);
6100	StringRef Delimiter = StringRef(FirstLine).take_front(N: DelimiterEnd);
6101	if (Delimiter.empty())
6102	return Error(L: DirectiveLoc, Msg: "no delimiter in 'comment' directive");
6103	do {
6104	if (getTok().is(K: AsmToken::Eof))
6105	return Error(L: DirectiveLoc, Msg: "unmatched delimiter in 'comment' directive");
6106	Lex(); // eat end of statement
6107	} while (
6108	!StringRef(parseStringTo(EndTok: AsmToken::EndOfStatement)).contains(Other: Delimiter));
6109	return parseEOL();
6110	}
6111
6112	/// parseDirectiveInclude
6113	/// ::= include <filename>
6114	/// | include filename
6115	bool MasmParser::parseDirectiveInclude() {
6116	// Allow the strings to have escaped octal character sequence.
6117	std::string Filename;
6118	SMLoc IncludeLoc = getTok().getLoc();
6119
6120	if (parseAngleBracketString(Data&: Filename))
6121	Filename = parseStringTo(EndTok: AsmToken::EndOfStatement);
6122	if (check(P: Filename.empty(), Msg: "missing filename in 'include' directive") ||
6123	check(P: getTok().isNot(K: AsmToken::EndOfStatement),
6124	Msg: "unexpected token in 'include' directive") ||
6125	// Attempt to switch the lexer to the included file before consuming the
6126	// end of statement to avoid losing it when we switch.
6127	check(P: enterIncludeFile(Filename), Loc: IncludeLoc,
6128	Msg: "Could not find include file '" + Filename + "'"))
6129	return true;
6130
6131	return false;
6132	}
6133
6134	/// parseDirectiveIf
6135	/// ::= .if{,eq,ge,gt,le,lt,ne} expression
6136	bool MasmParser::parseDirectiveIf(SMLoc DirectiveLoc, DirectiveKind DirKind) {
6137	TheCondStack.push_back(x: TheCondState);
6138	TheCondState.TheCond = AsmCond::IfCond;
6139	if (TheCondState.Ignore) {
6140	eatToEndOfStatement();
6141	} else {
6142	int64_t ExprValue;
6143	if (parseAbsoluteExpression(Res&: ExprValue) || parseEOL())
6144	return true;
6145
6146	switch (DirKind) {
6147	default:
6148	llvm_unreachable("unsupported directive");
6149	case DK_IF:
6150	break;
6151	case DK_IFE:
6152	ExprValue = ExprValue == 0;
6153	break;
6154	}
6155
6156	TheCondState.CondMet = ExprValue;
6157	TheCondState.Ignore = !TheCondState.CondMet;
6158	}
6159
6160	return false;
6161	}
6162
6163	/// parseDirectiveIfb
6164	/// ::= .ifb textitem
6165	bool MasmParser::parseDirectiveIfb(SMLoc DirectiveLoc, bool ExpectBlank) {
6166	TheCondStack.push_back(x: TheCondState);
6167	TheCondState.TheCond = AsmCond::IfCond;
6168
6169	if (TheCondState.Ignore) {
6170	eatToEndOfStatement();
6171	} else {
6172	std::string Str;
6173	if (parseTextItem(Data&: Str))
6174	return TokError(Msg: "expected text item parameter for 'ifb' directive");
6175
6176	if (parseEOL())
6177	return true;
6178
6179	TheCondState.CondMet = ExpectBlank == Str.empty();
6180	TheCondState.Ignore = !TheCondState.CondMet;
6181	}
6182
6183	return false;
6184	}
6185
6186	/// parseDirectiveIfidn
6187	/// ::= ifidn textitem, textitem
6188	bool MasmParser::parseDirectiveIfidn(SMLoc DirectiveLoc, bool ExpectEqual,
6189	bool CaseInsensitive) {
6190	std::string String1, String2;
6191
6192	if (parseTextItem(Data&: String1)) {
6193	if (ExpectEqual)
6194	return TokError(Msg: "expected text item parameter for 'ifidn' directive");
6195	return TokError(Msg: "expected text item parameter for 'ifdif' directive");
6196	}
6197
6198	if (Lexer.isNot(K: AsmToken::Comma)) {
6199	if (ExpectEqual)
6200	return TokError(
6201	Msg: "expected comma after first string for 'ifidn' directive");
6202	return TokError(Msg: "expected comma after first string for 'ifdif' directive");
6203	}
6204	Lex();
6205
6206	if (parseTextItem(Data&: String2)) {
6207	if (ExpectEqual)
6208	return TokError(Msg: "expected text item parameter for 'ifidn' directive");
6209	return TokError(Msg: "expected text item parameter for 'ifdif' directive");
6210	}
6211
6212	TheCondStack.push_back(x: TheCondState);
6213	TheCondState.TheCond = AsmCond::IfCond;
6214	if (CaseInsensitive)
6215	TheCondState.CondMet =
6216	ExpectEqual == (StringRef(String1).equals_insensitive(RHS: String2));
6217	else
6218	TheCondState.CondMet = ExpectEqual == (String1 == String2);
6219	TheCondState.Ignore = !TheCondState.CondMet;
6220
6221	return false;
6222	}
6223
6224	/// parseDirectiveIfdef
6225	/// ::= ifdef symbol
6226	/// | ifdef variable
6227	bool MasmParser::parseDirectiveIfdef(SMLoc DirectiveLoc, bool expect_defined) {
6228	TheCondStack.push_back(x: TheCondState);
6229	TheCondState.TheCond = AsmCond::IfCond;
6230
6231	if (TheCondState.Ignore) {
6232	eatToEndOfStatement();
6233	} else {
6234	bool is_defined = false;
6235	MCRegister Reg;
6236	SMLoc StartLoc, EndLoc;
6237	is_defined =
6238	getTargetParser().tryParseRegister(Reg, StartLoc, EndLoc).isSuccess();
6239	if (!is_defined) {
6240	StringRef Name;
6241	if (check(P: parseIdentifier(Res&: Name), Msg: "expected identifier after 'ifdef'") ||
6242	parseEOL())
6243	return true;
6244
6245	if (BuiltinSymbolMap.contains(Key: Name.lower())) {
6246	is_defined = true;
6247	} else if (Variables.contains(Key: Name.lower())) {
6248	is_defined = true;
6249	} else {
6250	MCSymbol *Sym = getContext().lookupSymbol(Name: Name.lower());
6251	is_defined = (Sym && !Sym->isUndefined(SetUsed: false));
6252	}
6253	}
6254
6255	TheCondState.CondMet = (is_defined == expect_defined);
6256	TheCondState.Ignore = !TheCondState.CondMet;
6257	}
6258
6259	return false;
6260	}
6261
6262	/// parseDirectiveElseIf
6263	/// ::= elseif expression
6264	bool MasmParser::parseDirectiveElseIf(SMLoc DirectiveLoc,
6265	DirectiveKind DirKind) {
6266	if (TheCondState.TheCond != AsmCond::IfCond &&
6267	TheCondState.TheCond != AsmCond::ElseIfCond)
6268	return Error(L: DirectiveLoc, Msg: "Encountered a .elseif that doesn't follow an"
6269	" .if or an .elseif");
6270	TheCondState.TheCond = AsmCond::ElseIfCond;
6271
6272	bool LastIgnoreState = false;
6273	if (!TheCondStack.empty())
6274	LastIgnoreState = TheCondStack.back().Ignore;
6275	if (LastIgnoreState || TheCondState.CondMet) {
6276	TheCondState.Ignore = true;
6277	eatToEndOfStatement();
6278	} else {
6279	int64_t ExprValue;
6280	if (parseAbsoluteExpression(Res&: ExprValue))
6281	return true;
6282
6283	if (parseEOL())
6284	return true;
6285
6286	switch (DirKind) {
6287	default:
6288	llvm_unreachable("unsupported directive");
6289	case DK_ELSEIF:
6290	break;
6291	case DK_ELSEIFE:
6292	ExprValue = ExprValue == 0;
6293	break;
6294	}
6295
6296	TheCondState.CondMet = ExprValue;
6297	TheCondState.Ignore = !TheCondState.CondMet;
6298	}
6299
6300	return false;
6301	}
6302
6303	/// parseDirectiveElseIfb
6304	/// ::= elseifb textitem
6305	bool MasmParser::parseDirectiveElseIfb(SMLoc DirectiveLoc, bool ExpectBlank) {
6306	if (TheCondState.TheCond != AsmCond::IfCond &&
6307	TheCondState.TheCond != AsmCond::ElseIfCond)
6308	return Error(L: DirectiveLoc, Msg: "Encountered an elseif that doesn't follow an"
6309	" if or an elseif");
6310	TheCondState.TheCond = AsmCond::ElseIfCond;
6311
6312	bool LastIgnoreState = false;
6313	if (!TheCondStack.empty())
6314	LastIgnoreState = TheCondStack.back().Ignore;
6315	if (LastIgnoreState || TheCondState.CondMet) {
6316	TheCondState.Ignore = true;
6317	eatToEndOfStatement();
6318	} else {
6319	std::string Str;
6320	if (parseTextItem(Data&: Str)) {
6321	if (ExpectBlank)
6322	return TokError(Msg: "expected text item parameter for 'elseifb' directive");
6323	return TokError(Msg: "expected text item parameter for 'elseifnb' directive");
6324	}
6325
6326	if (parseEOL())
6327	return true;
6328
6329	TheCondState.CondMet = ExpectBlank == Str.empty();
6330	TheCondState.Ignore = !TheCondState.CondMet;
6331	}
6332
6333	return false;
6334	}
6335
6336	/// parseDirectiveElseIfdef
6337	/// ::= elseifdef symbol
6338	/// | elseifdef variable
6339	bool MasmParser::parseDirectiveElseIfdef(SMLoc DirectiveLoc,
6340	bool expect_defined) {
6341	if (TheCondState.TheCond != AsmCond::IfCond &&
6342	TheCondState.TheCond != AsmCond::ElseIfCond)
6343	return Error(L: DirectiveLoc, Msg: "Encountered an elseif that doesn't follow an"
6344	" if or an elseif");
6345	TheCondState.TheCond = AsmCond::ElseIfCond;
6346
6347	bool LastIgnoreState = false;
6348	if (!TheCondStack.empty())
6349	LastIgnoreState = TheCondStack.back().Ignore;
6350	if (LastIgnoreState || TheCondState.CondMet) {
6351	TheCondState.Ignore = true;
6352	eatToEndOfStatement();
6353	} else {
6354	bool is_defined = false;
6355	MCRegister Reg;
6356	SMLoc StartLoc, EndLoc;
6357	is_defined =
6358	getTargetParser().tryParseRegister(Reg, StartLoc, EndLoc).isSuccess();
6359	if (!is_defined) {
6360	StringRef Name;
6361	if (check(P: parseIdentifier(Res&: Name),
6362	Msg: "expected identifier after 'elseifdef'") ||
6363	parseEOL())
6364	return true;
6365
6366	if (BuiltinSymbolMap.contains(Key: Name.lower())) {
6367	is_defined = true;
6368	} else if (Variables.contains(Key: Name.lower())) {
6369	is_defined = true;
6370	} else {
6371	MCSymbol *Sym = getContext().lookupSymbol(Name);
6372	is_defined = (Sym && !Sym->isUndefined(SetUsed: false));
6373	}
6374	}
6375
6376	TheCondState.CondMet = (is_defined == expect_defined);
6377	TheCondState.Ignore = !TheCondState.CondMet;
6378	}
6379
6380	return false;
6381	}
6382
6383	/// parseDirectiveElseIfidn
6384	/// ::= elseifidn textitem, textitem
6385	bool MasmParser::parseDirectiveElseIfidn(SMLoc DirectiveLoc, bool ExpectEqual,
6386	bool CaseInsensitive) {
6387	if (TheCondState.TheCond != AsmCond::IfCond &&
6388	TheCondState.TheCond != AsmCond::ElseIfCond)
6389	return Error(L: DirectiveLoc, Msg: "Encountered an elseif that doesn't follow an"
6390	" if or an elseif");
6391	TheCondState.TheCond = AsmCond::ElseIfCond;
6392
6393	bool LastIgnoreState = false;
6394	if (!TheCondStack.empty())
6395	LastIgnoreState = TheCondStack.back().Ignore;
6396	if (LastIgnoreState || TheCondState.CondMet) {
6397	TheCondState.Ignore = true;
6398	eatToEndOfStatement();
6399	} else {
6400	std::string String1, String2;
6401
6402	if (parseTextItem(Data&: String1)) {
6403	if (ExpectEqual)
6404	return TokError(
6405	Msg: "expected text item parameter for 'elseifidn' directive");
6406	return TokError(Msg: "expected text item parameter for 'elseifdif' directive");
6407	}
6408
6409	if (Lexer.isNot(K: AsmToken::Comma)) {
6410	if (ExpectEqual)
6411	return TokError(
6412	Msg: "expected comma after first string for 'elseifidn' directive");
6413	return TokError(
6414	Msg: "expected comma after first string for 'elseifdif' directive");
6415	}
6416	Lex();
6417
6418	if (parseTextItem(Data&: String2)) {
6419	if (ExpectEqual)
6420	return TokError(
6421	Msg: "expected text item parameter for 'elseifidn' directive");
6422	return TokError(Msg: "expected text item parameter for 'elseifdif' directive");
6423	}
6424
6425	if (CaseInsensitive)
6426	TheCondState.CondMet =
6427	ExpectEqual == (StringRef(String1).equals_insensitive(RHS: String2));
6428	else
6429	TheCondState.CondMet = ExpectEqual == (String1 == String2);
6430	TheCondState.Ignore = !TheCondState.CondMet;
6431	}
6432
6433	return false;
6434	}
6435
6436	/// parseDirectiveElse
6437	/// ::= else
6438	bool MasmParser::parseDirectiveElse(SMLoc DirectiveLoc) {
6439	if (parseEOL())
6440	return true;
6441
6442	if (TheCondState.TheCond != AsmCond::IfCond &&
6443	TheCondState.TheCond != AsmCond::ElseIfCond)
6444	return Error(L: DirectiveLoc, Msg: "Encountered an else that doesn't follow an if"
6445	" or an elseif");
6446	TheCondState.TheCond = AsmCond::ElseCond;
6447	bool LastIgnoreState = false;
6448	if (!TheCondStack.empty())
6449	LastIgnoreState = TheCondStack.back().Ignore;
6450	if (LastIgnoreState || TheCondState.CondMet)
6451	TheCondState.Ignore = true;
6452	else
6453	TheCondState.Ignore = false;
6454
6455	return false;
6456	}
6457
6458	/// parseDirectiveEnd
6459	/// ::= end
6460	bool MasmParser::parseDirectiveEnd(SMLoc DirectiveLoc) {
6461	if (parseEOL())
6462	return true;
6463
6464	while (Lexer.isNot(K: AsmToken::Eof))
6465	Lexer.Lex();
6466
6467	return false;
6468	}
6469
6470	/// parseDirectiveError
6471	/// ::= .err [message]
6472	bool MasmParser::parseDirectiveError(SMLoc DirectiveLoc) {
6473	if (!TheCondStack.empty()) {
6474	if (TheCondStack.back().Ignore) {
6475	eatToEndOfStatement();
6476	return false;
6477	}
6478	}
6479
6480	std::string Message = ".err directive invoked in source file";
6481	if (Lexer.isNot(K: AsmToken::EndOfStatement))
6482	Message = parseStringTo(EndTok: AsmToken::EndOfStatement);
6483	Lex();
6484
6485	return Error(L: DirectiveLoc, Msg: Message);
6486	}
6487
6488	/// parseDirectiveErrorIfb
6489	/// ::= .errb textitem[, message]
6490	bool MasmParser::parseDirectiveErrorIfb(SMLoc DirectiveLoc, bool ExpectBlank) {
6491	if (!TheCondStack.empty()) {
6492	if (TheCondStack.back().Ignore) {
6493	eatToEndOfStatement();
6494	return false;
6495	}
6496	}
6497
6498	std::string Text;
6499	if (parseTextItem(Data&: Text))
6500	return Error(L: getTok().getLoc(), Msg: "missing text item in '.errb' directive");
6501
6502	std::string Message = ".errb directive invoked in source file";
6503	if (Lexer.isNot(K: AsmToken::EndOfStatement)) {
6504	if (parseToken(T: AsmToken::Comma))
6505	return addErrorSuffix(Suffix: " in '.errb' directive");
6506	Message = parseStringTo(EndTok: AsmToken::EndOfStatement);
6507	}
6508	Lex();
6509
6510	if (Text.empty() == ExpectBlank)
6511	return Error(L: DirectiveLoc, Msg: Message);
6512	return false;
6513	}
6514
6515	/// parseDirectiveErrorIfdef
6516	/// ::= .errdef name[, message]
6517	bool MasmParser::parseDirectiveErrorIfdef(SMLoc DirectiveLoc,
6518	bool ExpectDefined) {
6519	if (!TheCondStack.empty()) {
6520	if (TheCondStack.back().Ignore) {
6521	eatToEndOfStatement();
6522	return false;
6523	}
6524	}
6525
6526	bool IsDefined = false;
6527	MCRegister Reg;
6528	SMLoc StartLoc, EndLoc;
6529	IsDefined =
6530	getTargetParser().tryParseRegister(Reg, StartLoc, EndLoc).isSuccess();
6531	if (!IsDefined) {
6532	StringRef Name;
6533	if (check(P: parseIdentifier(Res&: Name), Msg: "expected identifier after '.errdef'"))
6534	return true;
6535
6536	if (BuiltinSymbolMap.contains(Key: Name.lower())) {
6537	IsDefined = true;
6538	} else if (Variables.contains(Key: Name.lower())) {
6539	IsDefined = true;
6540	} else {
6541	MCSymbol *Sym = getContext().lookupSymbol(Name);
6542	IsDefined = (Sym && !Sym->isUndefined(SetUsed: false));
6543	}
6544	}
6545
6546	std::string Message = ".errdef directive invoked in source file";
6547	if (Lexer.isNot(K: AsmToken::EndOfStatement)) {
6548	if (parseToken(T: AsmToken::Comma))
6549	return addErrorSuffix(Suffix: " in '.errdef' directive");
6550	Message = parseStringTo(EndTok: AsmToken::EndOfStatement);
6551	}
6552	Lex();
6553
6554	if (IsDefined == ExpectDefined)
6555	return Error(L: DirectiveLoc, Msg: Message);
6556	return false;
6557	}
6558
6559	/// parseDirectiveErrorIfidn
6560	/// ::= .erridn textitem, textitem[, message]
6561	bool MasmParser::parseDirectiveErrorIfidn(SMLoc DirectiveLoc, bool ExpectEqual,
6562	bool CaseInsensitive) {
6563	if (!TheCondStack.empty()) {
6564	if (TheCondStack.back().Ignore) {
6565	eatToEndOfStatement();
6566	return false;
6567	}
6568	}
6569
6570	std::string String1, String2;
6571
6572	if (parseTextItem(Data&: String1)) {
6573	if (ExpectEqual)
6574	return TokError(Msg: "expected string parameter for '.erridn' directive");
6575	return TokError(Msg: "expected string parameter for '.errdif' directive");
6576	}
6577
6578	if (Lexer.isNot(K: AsmToken::Comma)) {
6579	if (ExpectEqual)
6580	return TokError(
6581	Msg: "expected comma after first string for '.erridn' directive");
6582	return TokError(
6583	Msg: "expected comma after first string for '.errdif' directive");
6584	}
6585	Lex();
6586
6587	if (parseTextItem(Data&: String2)) {
6588	if (ExpectEqual)
6589	return TokError(Msg: "expected string parameter for '.erridn' directive");
6590	return TokError(Msg: "expected string parameter for '.errdif' directive");
6591	}
6592
6593	std::string Message;
6594	if (ExpectEqual)
6595	Message = ".erridn directive invoked in source file";
6596	else
6597	Message = ".errdif directive invoked in source file";
6598	if (Lexer.isNot(K: AsmToken::EndOfStatement)) {
6599	if (parseToken(T: AsmToken::Comma))
6600	return addErrorSuffix(Suffix: " in '.erridn' directive");
6601	Message = parseStringTo(EndTok: AsmToken::EndOfStatement);
6602	}
6603	Lex();
6604
6605	if (CaseInsensitive)
6606	TheCondState.CondMet =
6607	ExpectEqual == (StringRef(String1).equals_insensitive(RHS: String2));
6608	else
6609	TheCondState.CondMet = ExpectEqual == (String1 == String2);
6610	TheCondState.Ignore = !TheCondState.CondMet;
6611
6612	if ((CaseInsensitive &&
6613	ExpectEqual == StringRef(String1).equals_insensitive(RHS: String2)) ||
6614	(ExpectEqual == (String1 == String2)))
6615	return Error(L: DirectiveLoc, Msg: Message);
6616	return false;
6617	}
6618
6619	/// parseDirectiveErrorIfe
6620	/// ::= .erre expression[, message]
6621	bool MasmParser::parseDirectiveErrorIfe(SMLoc DirectiveLoc, bool ExpectZero) {
6622	if (!TheCondStack.empty()) {
6623	if (TheCondStack.back().Ignore) {
6624	eatToEndOfStatement();
6625	return false;
6626	}
6627	}
6628
6629	int64_t ExprValue;
6630	if (parseAbsoluteExpression(Res&: ExprValue))
6631	return addErrorSuffix(Suffix: " in '.erre' directive");
6632
6633	std::string Message = ".erre directive invoked in source file";
6634	if (Lexer.isNot(K: AsmToken::EndOfStatement)) {
6635	if (parseToken(T: AsmToken::Comma))
6636	return addErrorSuffix(Suffix: " in '.erre' directive");
6637	Message = parseStringTo(EndTok: AsmToken::EndOfStatement);
6638	}
6639	Lex();
6640
6641	if ((ExprValue == 0) == ExpectZero)
6642	return Error(L: DirectiveLoc, Msg: Message);
6643	return false;
6644	}
6645
6646	/// parseDirectiveEndIf
6647	/// ::= .endif
6648	bool MasmParser::parseDirectiveEndIf(SMLoc DirectiveLoc) {
6649	if (parseEOL())
6650	return true;
6651
6652	if ((TheCondState.TheCond == AsmCond::NoCond) || TheCondStack.empty())
6653	return Error(L: DirectiveLoc, Msg: "Encountered a .endif that doesn't follow "
6654	"an .if or .else");
6655	if (!TheCondStack.empty()) {
6656	TheCondState = TheCondStack.back();
6657	TheCondStack.pop_back();
6658	}
6659
6660	return false;
6661	}
6662
6663	void MasmParser::initializeDirectiveKindMap() {
6664	DirectiveKindMap["="] = DK_ASSIGN;
6665	DirectiveKindMap["equ"] = DK_EQU;
6666	DirectiveKindMap["textequ"] = DK_TEXTEQU;
6667	// DirectiveKindMap[".ascii"] = DK_ASCII;
6668	// DirectiveKindMap[".asciz"] = DK_ASCIZ;
6669	// DirectiveKindMap[".string"] = DK_STRING;
6670	DirectiveKindMap["byte"] = DK_BYTE;
6671	DirectiveKindMap["sbyte"] = DK_SBYTE;
6672	DirectiveKindMap["word"] = DK_WORD;
6673	DirectiveKindMap["sword"] = DK_SWORD;
6674	DirectiveKindMap["dword"] = DK_DWORD;
6675	DirectiveKindMap["sdword"] = DK_SDWORD;
6676	DirectiveKindMap["fword"] = DK_FWORD;
6677	DirectiveKindMap["qword"] = DK_QWORD;
6678	DirectiveKindMap["sqword"] = DK_SQWORD;
6679	DirectiveKindMap["real4"] = DK_REAL4;
6680	DirectiveKindMap["real8"] = DK_REAL8;
6681	DirectiveKindMap["real10"] = DK_REAL10;
6682	DirectiveKindMap["align"] = DK_ALIGN;
6683	DirectiveKindMap["even"] = DK_EVEN;
6684	DirectiveKindMap["org"] = DK_ORG;
6685	DirectiveKindMap["extern"] = DK_EXTERN;
6686	DirectiveKindMap["extrn"] = DK_EXTERN;
6687	DirectiveKindMap["public"] = DK_PUBLIC;
6688	// DirectiveKindMap[".comm"] = DK_COMM;
6689	DirectiveKindMap["comment"] = DK_COMMENT;
6690	DirectiveKindMap["include"] = DK_INCLUDE;
6691	DirectiveKindMap["repeat"] = DK_REPEAT;
6692	DirectiveKindMap["rept"] = DK_REPEAT;
6693	DirectiveKindMap["while"] = DK_WHILE;
6694	DirectiveKindMap["for"] = DK_FOR;
6695	DirectiveKindMap["irp"] = DK_FOR;
6696	DirectiveKindMap["forc"] = DK_FORC;
6697	DirectiveKindMap["irpc"] = DK_FORC;
6698	DirectiveKindMap["if"] = DK_IF;
6699	DirectiveKindMap["ife"] = DK_IFE;
6700	DirectiveKindMap["ifb"] = DK_IFB;
6701	DirectiveKindMap["ifnb"] = DK_IFNB;
6702	DirectiveKindMap["ifdef"] = DK_IFDEF;
6703	DirectiveKindMap["ifndef"] = DK_IFNDEF;
6704	DirectiveKindMap["ifdif"] = DK_IFDIF;
6705	DirectiveKindMap["ifdifi"] = DK_IFDIFI;
6706	DirectiveKindMap["ifidn"] = DK_IFIDN;
6707	DirectiveKindMap["ifidni"] = DK_IFIDNI;
6708	DirectiveKindMap["elseif"] = DK_ELSEIF;
6709	DirectiveKindMap["elseifdef"] = DK_ELSEIFDEF;
6710	DirectiveKindMap["elseifndef"] = DK_ELSEIFNDEF;
6711	DirectiveKindMap["elseifdif"] = DK_ELSEIFDIF;
6712	DirectiveKindMap["elseifidn"] = DK_ELSEIFIDN;
6713	DirectiveKindMap["else"] = DK_ELSE;
6714	DirectiveKindMap["end"] = DK_END;
6715	DirectiveKindMap["endif"] = DK_ENDIF;
6716	// DirectiveKindMap[".file"] = DK_FILE;
6717	// DirectiveKindMap[".line"] = DK_LINE;
6718	// DirectiveKindMap[".loc"] = DK_LOC;
6719	// DirectiveKindMap[".stabs"] = DK_STABS;
6720	// DirectiveKindMap[".cv_file"] = DK_CV_FILE;
6721	// DirectiveKindMap[".cv_func_id"] = DK_CV_FUNC_ID;
6722	// DirectiveKindMap[".cv_loc"] = DK_CV_LOC;
6723	// DirectiveKindMap[".cv_linetable"] = DK_CV_LINETABLE;
6724	// DirectiveKindMap[".cv_inline_linetable"] = DK_CV_INLINE_LINETABLE;
6725	// DirectiveKindMap[".cv_inline_site_id"] = DK_CV_INLINE_SITE_ID;
6726	// DirectiveKindMap[".cv_def_range"] = DK_CV_DEF_RANGE;
6727	// DirectiveKindMap[".cv_string"] = DK_CV_STRING;
6728	// DirectiveKindMap[".cv_stringtable"] = DK_CV_STRINGTABLE;
6729	// DirectiveKindMap[".cv_filechecksums"] = DK_CV_FILECHECKSUMS;
6730	// DirectiveKindMap[".cv_filechecksumoffset"] = DK_CV_FILECHECKSUM_OFFSET;
6731	// DirectiveKindMap[".cv_fpo_data"] = DK_CV_FPO_DATA;
6732	// DirectiveKindMap[".cfi_sections"] = DK_CFI_SECTIONS;
6733	// DirectiveKindMap[".cfi_startproc"] = DK_CFI_STARTPROC;
6734	// DirectiveKindMap[".cfi_endproc"] = DK_CFI_ENDPROC;
6735	// DirectiveKindMap[".cfi_def_cfa"] = DK_CFI_DEF_CFA;
6736	// DirectiveKindMap[".cfi_def_cfa_offset"] = DK_CFI_DEF_CFA_OFFSET;
6737	// DirectiveKindMap[".cfi_adjust_cfa_offset"] = DK_CFI_ADJUST_CFA_OFFSET;
6738	// DirectiveKindMap[".cfi_def_cfa_register"] = DK_CFI_DEF_CFA_REGISTER;
6739	// DirectiveKindMap[".cfi_offset"] = DK_CFI_OFFSET;
6740	// DirectiveKindMap[".cfi_rel_offset"] = DK_CFI_REL_OFFSET;
6741	// DirectiveKindMap[".cfi_personality"] = DK_CFI_PERSONALITY;
6742	// DirectiveKindMap[".cfi_lsda"] = DK_CFI_LSDA;
6743	// DirectiveKindMap[".cfi_remember_state"] = DK_CFI_REMEMBER_STATE;
6744	// DirectiveKindMap[".cfi_restore_state"] = DK_CFI_RESTORE_STATE;
6745	// DirectiveKindMap[".cfi_same_value"] = DK_CFI_SAME_VALUE;
6746	// DirectiveKindMap[".cfi_restore"] = DK_CFI_RESTORE;
6747	// DirectiveKindMap[".cfi_escape"] = DK_CFI_ESCAPE;
6748	// DirectiveKindMap[".cfi_return_column"] = DK_CFI_RETURN_COLUMN;
6749	// DirectiveKindMap[".cfi_signal_frame"] = DK_CFI_SIGNAL_FRAME;
6750	// DirectiveKindMap[".cfi_undefined"] = DK_CFI_UNDEFINED;
6751	// DirectiveKindMap[".cfi_register"] = DK_CFI_REGISTER;
6752	// DirectiveKindMap[".cfi_window_save"] = DK_CFI_WINDOW_SAVE;
6753	// DirectiveKindMap[".cfi_b_key_frame"] = DK_CFI_B_KEY_FRAME;
6754	DirectiveKindMap["macro"] = DK_MACRO;
6755	DirectiveKindMap["exitm"] = DK_EXITM;
6756	DirectiveKindMap["endm"] = DK_ENDM;
6757	DirectiveKindMap["purge"] = DK_PURGE;
6758	DirectiveKindMap[".err"] = DK_ERR;
6759	DirectiveKindMap[".errb"] = DK_ERRB;
6760	DirectiveKindMap[".errnb"] = DK_ERRNB;
6761	DirectiveKindMap[".errdef"] = DK_ERRDEF;
6762	DirectiveKindMap[".errndef"] = DK_ERRNDEF;
6763	DirectiveKindMap[".errdif"] = DK_ERRDIF;
6764	DirectiveKindMap[".errdifi"] = DK_ERRDIFI;
6765	DirectiveKindMap[".erridn"] = DK_ERRIDN;
6766	DirectiveKindMap[".erridni"] = DK_ERRIDNI;
6767	DirectiveKindMap[".erre"] = DK_ERRE;
6768	DirectiveKindMap[".errnz"] = DK_ERRNZ;
6769	DirectiveKindMap[".pushframe"] = DK_PUSHFRAME;
6770	DirectiveKindMap[".pushreg"] = DK_PUSHREG;
6771	DirectiveKindMap[".savereg"] = DK_SAVEREG;
6772	DirectiveKindMap[".savexmm128"] = DK_SAVEXMM128;
6773	DirectiveKindMap[".setframe"] = DK_SETFRAME;
6774	DirectiveKindMap[".radix"] = DK_RADIX;
6775	DirectiveKindMap["db"] = DK_DB;
6776	DirectiveKindMap["dd"] = DK_DD;
6777	DirectiveKindMap["df"] = DK_DF;
6778	DirectiveKindMap["dq"] = DK_DQ;
6779	DirectiveKindMap["dw"] = DK_DW;
6780	DirectiveKindMap["echo"] = DK_ECHO;
6781	DirectiveKindMap["struc"] = DK_STRUCT;
6782	DirectiveKindMap["struct"] = DK_STRUCT;
6783	DirectiveKindMap["union"] = DK_UNION;
6784	DirectiveKindMap["ends"] = DK_ENDS;
6785	}
6786
6787	bool MasmParser::isMacroLikeDirective() {
6788	if (getLexer().is(K: AsmToken::Identifier)) {
6789	bool IsMacroLike = StringSwitch<bool>(getTok().getIdentifier())
6790	.CasesLower(S0: "repeat", S1: "rept", Value: true)
6791	.CaseLower(S: "while", Value: true)
6792	.CasesLower(S0: "for", S1: "irp", Value: true)
6793	.CasesLower(S0: "forc", S1: "irpc", Value: true)
6794	.Default(Value: false);
6795	if (IsMacroLike)
6796	return true;
6797	}
6798	if (peekTok().is(K: AsmToken::Identifier) &&
6799	peekTok().getIdentifier().equals_insensitive(RHS: "macro"))
6800	return true;
6801
6802	return false;
6803	}
6804
6805	MCAsmMacro *MasmParser::parseMacroLikeBody(SMLoc DirectiveLoc) {
6806	AsmToken EndToken, StartToken = getTok();
6807
6808	unsigned NestLevel = 0;
6809	while (true) {
6810	// Check whether we have reached the end of the file.
6811	if (getLexer().is(K: AsmToken::Eof)) {
6812	printError(L: DirectiveLoc, Msg: "no matching 'endm' in definition");
6813	return nullptr;
6814	}
6815
6816	if (isMacroLikeDirective())
6817	++NestLevel;
6818
6819	// Otherwise, check whether we have reached the endm.
6820	if (Lexer.is(K: AsmToken::Identifier) &&
6821	getTok().getIdentifier().equals_insensitive(RHS: "endm")) {
6822	if (NestLevel == 0) {
6823	EndToken = getTok();
6824	Lex();
6825	if (Lexer.isNot(K: AsmToken::EndOfStatement)) {
6826	printError(L: getTok().getLoc(), Msg: "unexpected token in 'endm' directive");
6827	return nullptr;
6828	}
6829	break;
6830	}
6831	--NestLevel;
6832	}
6833
6834	// Otherwise, scan till the end of the statement.
6835	eatToEndOfStatement();
6836	}
6837
6838	const char *BodyStart = StartToken.getLoc().getPointer();
6839	const char *BodyEnd = EndToken.getLoc().getPointer();
6840	StringRef Body = StringRef(BodyStart, BodyEnd - BodyStart);
6841
6842	// We Are Anonymous.
6843	MacroLikeBodies.emplace_back(args: StringRef(), args&: Body, args: MCAsmMacroParameters());
6844	return &MacroLikeBodies.back();
6845	}
6846
6847	bool MasmParser::expandStatement(SMLoc Loc) {
6848	std::string Body = parseStringTo(EndTok: AsmToken::EndOfStatement);
6849	SMLoc EndLoc = getTok().getLoc();
6850
6851	MCAsmMacroParameters Parameters;
6852	MCAsmMacroArguments Arguments;
6853
6854	StringMap<std::string> BuiltinValues;
6855	for (const auto &S : BuiltinSymbolMap) {
6856	const BuiltinSymbol &Sym = S.getValue();
6857	if (std::optional<std::string> Text = evaluateBuiltinTextMacro(Symbol: Sym, StartLoc: Loc)) {
6858	BuiltinValues[S.getKey().lower()] = std::move(*Text);
6859	}
6860	}
6861	for (const auto &B : BuiltinValues) {
6862	MCAsmMacroParameter P;
6863	MCAsmMacroArgument A;
6864	P.Name = B.getKey();
6865	P.Required = true;
6866	A.push_back(x: AsmToken(AsmToken::String, B.getValue()));
6867
6868	Parameters.push_back(x: std::move(P));
6869	Arguments.push_back(x: std::move(A));
6870	}
6871
6872	for (const auto &V : Variables) {
6873	const Variable &Var = V.getValue();
6874	if (Var.IsText) {
6875	MCAsmMacroParameter P;
6876	MCAsmMacroArgument A;
6877	P.Name = Var.Name;
6878	P.Required = true;
6879	A.push_back(x: AsmToken(AsmToken::String, Var.TextValue));
6880
6881	Parameters.push_back(x: std::move(P));
6882	Arguments.push_back(x: std::move(A));
6883	}
6884	}
6885	MacroLikeBodies.emplace_back(args: StringRef(), args&: Body, args&: Parameters);
6886	MCAsmMacro M = MacroLikeBodies.back();
6887
6888	// Expand the statement in a new buffer.
6889	SmallString<80> Buf;
6890	raw_svector_ostream OS(Buf);
6891	if (expandMacro(OS, Body: M.Body, Parameters: M.Parameters, A: Arguments, Locals: M.Locals, L: EndLoc))
6892	return true;
6893	std::unique_ptr<MemoryBuffer> Expansion =
6894	MemoryBuffer::getMemBufferCopy(InputData: OS.str(), BufferName: "<expansion>");
6895
6896	// Jump to the expanded statement and prime the lexer.
6897	CurBuffer = SrcMgr.AddNewSourceBuffer(F: std::move(Expansion), IncludeLoc: EndLoc);
6898	Lexer.setBuffer(Buf: SrcMgr.getMemoryBuffer(i: CurBuffer)->getBuffer());
6899	EndStatementAtEOFStack.push_back(Val: false);
6900	Lex();
6901	return false;
6902	}
6903
6904	void MasmParser::instantiateMacroLikeBody(MCAsmMacro *M, SMLoc DirectiveLoc,
6905	raw_svector_ostream &OS) {
6906	instantiateMacroLikeBody(M, DirectiveLoc, /*ExitLoc=*/getTok().getLoc(), OS);
6907	}
6908	void MasmParser::instantiateMacroLikeBody(MCAsmMacro *M, SMLoc DirectiveLoc,
6909	SMLoc ExitLoc,
6910	raw_svector_ostream &OS) {
6911	OS << "endm\n";
6912
6913	std::unique_ptr<MemoryBuffer> Instantiation =
6914	MemoryBuffer::getMemBufferCopy(InputData: OS.str(), BufferName: "<instantiation>");
6915
6916	// Create the macro instantiation object and add to the current macro
6917	// instantiation stack.
6918	MacroInstantiation *MI = new MacroInstantiation{.InstantiationLoc: DirectiveLoc, .ExitBuffer: CurBuffer,
6919	.ExitLoc: ExitLoc, .CondStackDepth: TheCondStack.size()};
6920	ActiveMacros.push_back(x: MI);
6921
6922	// Jump to the macro instantiation and prime the lexer.
6923	CurBuffer = SrcMgr.AddNewSourceBuffer(F: std::move(Instantiation), IncludeLoc: SMLoc());
6924	Lexer.setBuffer(Buf: SrcMgr.getMemoryBuffer(i: CurBuffer)->getBuffer());
6925	EndStatementAtEOFStack.push_back(Val: true);
6926	Lex();
6927	}
6928
6929	/// parseDirectiveRepeat
6930	/// ::= ("repeat" | "rept") count
6931	/// body
6932	/// endm
6933	bool MasmParser::parseDirectiveRepeat(SMLoc DirectiveLoc, StringRef Dir) {
6934	const MCExpr *CountExpr;
6935	SMLoc CountLoc = getTok().getLoc();
6936	if (parseExpression(Res&: CountExpr))
6937	return true;
6938
6939	int64_t Count;
6940	if (!CountExpr->evaluateAsAbsolute(Res&: Count, Asm: getStreamer().getAssemblerPtr())) {
6941	return Error(L: CountLoc, Msg: "unexpected token in '" + Dir + "' directive");
6942	}
6943
6944	if (check(P: Count < 0, Loc: CountLoc, Msg: "Count is negative") || parseEOL())
6945	return true;
6946
6947	// Lex the repeat definition.
6948	MCAsmMacro *M = parseMacroLikeBody(DirectiveLoc);
6949	if (!M)
6950	return true;
6951
6952	// Macro instantiation is lexical, unfortunately. We construct a new buffer
6953	// to hold the macro body with substitutions.
6954	SmallString<256> Buf;
6955	raw_svector_ostream OS(Buf);
6956	while (Count--) {
6957	if (expandMacro(OS, Body: M->Body, Parameters: std::nullopt, A: std::nullopt, Locals: M->Locals,
6958	L: getTok().getLoc()))
6959	return true;
6960	}
6961	instantiateMacroLikeBody(M, DirectiveLoc, OS);
6962
6963	return false;
6964	}
6965
6966	/// parseDirectiveWhile
6967	/// ::= "while" expression
6968	/// body
6969	/// endm
6970	bool MasmParser::parseDirectiveWhile(SMLoc DirectiveLoc) {
6971	const MCExpr *CondExpr;
6972	SMLoc CondLoc = getTok().getLoc();
6973	if (parseExpression(Res&: CondExpr))
6974	return true;
6975
6976	// Lex the repeat definition.
6977	MCAsmMacro *M = parseMacroLikeBody(DirectiveLoc);
6978	if (!M)
6979	return true;
6980
6981	// Macro instantiation is lexical, unfortunately. We construct a new buffer
6982	// to hold the macro body with substitutions.
6983	SmallString<256> Buf;
6984	raw_svector_ostream OS(Buf);
6985	int64_t Condition;
6986	if (!CondExpr->evaluateAsAbsolute(Res&: Condition, Asm: getStreamer().getAssemblerPtr()))
6987	return Error(L: CondLoc, Msg: "expected absolute expression in 'while' directive");
6988	if (Condition) {
6989	// Instantiate the macro, then resume at this directive to recheck the
6990	// condition.
6991	if (expandMacro(OS, Body: M->Body, Parameters: std::nullopt, A: std::nullopt, Locals: M->Locals,
6992	L: getTok().getLoc()))
6993	return true;
6994	instantiateMacroLikeBody(M, DirectiveLoc, /*ExitLoc=*/DirectiveLoc, OS);
6995	}
6996
6997	return false;
6998	}
6999
7000	/// parseDirectiveFor
7001	/// ::= ("for" | "irp") symbol [":" qualifier], <values>
7002	/// body
7003	/// endm
7004	bool MasmParser::parseDirectiveFor(SMLoc DirectiveLoc, StringRef Dir) {
7005	MCAsmMacroParameter Parameter;
7006	MCAsmMacroArguments A;
7007	if (check(P: parseIdentifier(Res&: Parameter.Name),
7008	Msg: "expected identifier in '" + Dir + "' directive"))
7009	return true;
7010
7011	// Parse optional qualifier (default value, or "req")
7012	if (parseOptionalToken(T: AsmToken::Colon)) {
7013	if (parseOptionalToken(T: AsmToken::Equal)) {
7014	// Default value
7015	SMLoc ParamLoc;
7016
7017	ParamLoc = Lexer.getLoc();
7018	if (parseMacroArgument(MP: nullptr, MA&: Parameter.Value))
7019	return true;
7020	} else {
7021	SMLoc QualLoc;
7022	StringRef Qualifier;
7023
7024	QualLoc = Lexer.getLoc();
7025	if (parseIdentifier(Res&: Qualifier))
7026	return Error(L: QualLoc, Msg: "missing parameter qualifier for "
7027	"'" +
7028	Parameter.Name + "' in '" + Dir +
7029	"' directive");
7030
7031	if (Qualifier.equals_insensitive(RHS: "req"))
7032	Parameter.Required = true;
7033	else
7034	return Error(L: QualLoc,
7035	Msg: Qualifier + " is not a valid parameter qualifier for '" +
7036	Parameter.Name + "' in '" + Dir + "' directive");
7037	}
7038	}
7039
7040	if (parseToken(T: AsmToken::Comma,
7041	Msg: "expected comma in '" + Dir + "' directive") ||
7042	parseToken(T: AsmToken::Less,
7043	Msg: "values in '" + Dir +
7044	"' directive must be enclosed in angle brackets"))
7045	return true;
7046
7047	while (true) {
7048	A.emplace_back();
7049	if (parseMacroArgument(MP: &Parameter, MA&: A.back(), /*EndTok=*/AsmToken::Greater))
7050	return addErrorSuffix(Suffix: " in arguments for '" + Dir + "' directive");
7051
7052	// If we see a comma, continue, and allow line continuation.
7053	if (!parseOptionalToken(T: AsmToken::Comma))
7054	break;
7055	parseOptionalToken(T: AsmToken::EndOfStatement);
7056	}
7057
7058	if (parseToken(T: AsmToken::Greater,
7059	Msg: "values in '" + Dir +
7060	"' directive must be enclosed in angle brackets") ||
7061	parseEOL())
7062	return true;
7063
7064	// Lex the for definition.
7065	MCAsmMacro *M = parseMacroLikeBody(DirectiveLoc);
7066	if (!M)
7067	return true;
7068
7069	// Macro instantiation is lexical, unfortunately. We construct a new buffer
7070	// to hold the macro body with substitutions.
7071	SmallString<256> Buf;
7072	raw_svector_ostream OS(Buf);
7073
7074	for (const MCAsmMacroArgument &Arg : A) {
7075	if (expandMacro(OS, Body: M->Body, Parameters: Parameter, A: Arg, Locals: M->Locals, L: getTok().getLoc()))
7076	return true;
7077	}
7078
7079	instantiateMacroLikeBody(M, DirectiveLoc, OS);
7080
7081	return false;
7082	}
7083
7084	/// parseDirectiveForc
7085	/// ::= ("forc" | "irpc") symbol, <string>
7086	/// body
7087	/// endm
7088	bool MasmParser::parseDirectiveForc(SMLoc DirectiveLoc, StringRef Directive) {
7089	MCAsmMacroParameter Parameter;
7090
7091	std::string Argument;
7092	if (check(P: parseIdentifier(Res&: Parameter.Name),
7093	Msg: "expected identifier in '" + Directive + "' directive") ||
7094	parseToken(T: AsmToken::Comma,
7095	Msg: "expected comma in '" + Directive + "' directive"))
7096	return true;
7097	if (parseAngleBracketString(Data&: Argument)) {
7098	// Match ml64.exe; treat all characters to end of statement as a string,
7099	// ignoring comment markers, then discard anything following a space (using
7100	// the C locale).
7101	Argument = parseStringTo(EndTok: AsmToken::EndOfStatement);
7102	if (getTok().is(K: AsmToken::EndOfStatement))
7103	Argument += getTok().getString();
7104	size_t End = 0;
7105	for (; End < Argument.size(); ++End) {
7106	if (isSpace(C: Argument[End]))
7107	break;
7108	}
7109	Argument.resize(n: End);
7110	}
7111	if (parseEOL())
7112	return true;
7113
7114	// Lex the irpc definition.
7115	MCAsmMacro *M = parseMacroLikeBody(DirectiveLoc);
7116	if (!M)
7117	return true;
7118
7119	// Macro instantiation is lexical, unfortunately. We construct a new buffer
7120	// to hold the macro body with substitutions.
7121	SmallString<256> Buf;
7122	raw_svector_ostream OS(Buf);
7123
7124	StringRef Values(Argument);
7125	for (std::size_t I = 0, End = Values.size(); I != End; ++I) {
7126	MCAsmMacroArgument Arg;
7127	Arg.emplace_back(args: AsmToken::Identifier, args: Values.slice(Start: I, End: I + 1));
7128
7129	if (expandMacro(OS, Body: M->Body, Parameters: Parameter, A: Arg, Locals: M->Locals, L: getTok().getLoc()))
7130	return true;
7131	}
7132
7133	instantiateMacroLikeBody(M, DirectiveLoc, OS);
7134
7135	return false;
7136	}
7137
7138	bool MasmParser::parseDirectiveMSEmit(SMLoc IDLoc, ParseStatementInfo &Info,
7139	size_t Len) {
7140	const MCExpr *Value;
7141	SMLoc ExprLoc = getLexer().getLoc();
7142	if (parseExpression(Res&: Value))
7143	return true;
7144	const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Val: Value);
7145	if (!MCE)
7146	return Error(L: ExprLoc, Msg: "unexpected expression in _emit");
7147	uint64_t IntValue = MCE->getValue();
7148	if (!isUInt<8>(x: IntValue) && !isInt<8>(x: IntValue))
7149	return Error(L: ExprLoc, Msg: "literal value out of range for directive");
7150
7151	Info.AsmRewrites->emplace_back(Args: AOK_Emit, Args&: IDLoc, Args&: Len);
7152	return false;
7153	}
7154
7155	bool MasmParser::parseDirectiveMSAlign(SMLoc IDLoc, ParseStatementInfo &Info) {
7156	const MCExpr *Value;
7157	SMLoc ExprLoc = getLexer().getLoc();
7158	if (parseExpression(Res&: Value))
7159	return true;
7160	const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Val: Value);
7161	if (!MCE)
7162	return Error(L: ExprLoc, Msg: "unexpected expression in align");
7163	uint64_t IntValue = MCE->getValue();
7164	if (!isPowerOf2_64(Value: IntValue))
7165	return Error(L: ExprLoc, Msg: "literal value not a power of two greater then zero");
7166
7167	Info.AsmRewrites->emplace_back(Args: AOK_Align, Args&: IDLoc, Args: 5, Args: Log2_64(Value: IntValue));
7168	return false;
7169	}
7170
7171	bool MasmParser::parseDirectiveRadix(SMLoc DirectiveLoc) {
7172	const SMLoc Loc = getLexer().getLoc();
7173	std::string RadixStringRaw = parseStringTo(EndTok: AsmToken::EndOfStatement);
7174	StringRef RadixString = StringRef(RadixStringRaw).trim();
7175	unsigned Radix;
7176	if (RadixString.getAsInteger(Radix: 10, Result&: Radix)) {
7177	return Error(L: Loc,
7178	Msg: "radix must be a decimal number in the range 2 to 16; was " +
7179	RadixString);
7180	}
7181	if (Radix < 2 || Radix > 16)
7182	return Error(L: Loc, Msg: "radix must be in the range 2 to 16; was " +
7183	std::to_string(val: Radix));
7184	getLexer().setMasmDefaultRadix(Radix);
7185	return false;
7186	}
7187
7188	/// parseDirectiveEcho
7189	/// ::= "echo" message
7190	bool MasmParser::parseDirectiveEcho(SMLoc DirectiveLoc) {
7191	std::string Message = parseStringTo(EndTok: AsmToken::EndOfStatement);
7192	llvm::outs() << Message;
7193	if (!StringRef(Message).ends_with(Suffix: "\n"))
7194	llvm::outs() << '\n';
7195	return false;
7196	}
7197
7198	// We are comparing pointers, but the pointers are relative to a single string.
7199	// Thus, this should always be deterministic.
7200	static int rewritesSort(const AsmRewrite *AsmRewriteA,
7201	const AsmRewrite *AsmRewriteB) {
7202	if (AsmRewriteA->Loc.getPointer() < AsmRewriteB->Loc.getPointer())
7203	return -1;
7204	if (AsmRewriteB->Loc.getPointer() < AsmRewriteA->Loc.getPointer())
7205	return 1;
7206
7207	// It's possible to have a SizeDirective, Imm/ImmPrefix and an Input/Output
7208	// rewrite to the same location. Make sure the SizeDirective rewrite is
7209	// performed first, then the Imm/ImmPrefix and finally the Input/Output. This
7210	// ensures the sort algorithm is stable.
7211	if (AsmRewritePrecedence[AsmRewriteA->Kind] >
7212	AsmRewritePrecedence[AsmRewriteB->Kind])
7213	return -1;
7214
7215	if (AsmRewritePrecedence[AsmRewriteA->Kind] <
7216	AsmRewritePrecedence[AsmRewriteB->Kind])
7217	return 1;
7218	llvm_unreachable("Unstable rewrite sort.");
7219	}
7220
7221	bool MasmParser::defineMacro(StringRef Name, StringRef Value) {
7222	Variable &Var = Variables[Name.lower()];
7223	if (Var.Name.empty()) {
7224	Var.Name = Name;
7225	} else if (Var.Redefinable == Variable::NOT_REDEFINABLE) {
7226	return Error(L: SMLoc(), Msg: "invalid variable redefinition");
7227	} else if (Var.Redefinable == Variable::WARN_ON_REDEFINITION &&
7228	Warning(L: SMLoc(), Msg: "redefining '" + Name +
7229	"', already defined on the command line")) {
7230	return true;
7231	}
7232	Var.Redefinable = Variable::WARN_ON_REDEFINITION;
7233	Var.IsText = true;
7234	Var.TextValue = Value.str();
7235	return false;
7236	}
7237
7238	bool MasmParser::lookUpField(StringRef Name, AsmFieldInfo &Info) const {
7239	const std::pair<StringRef, StringRef> BaseMember = Name.split(Separator: '.');
7240	const StringRef Base = BaseMember.first, Member = BaseMember.second;
7241	return lookUpField(Base, Member, Info);
7242	}
7243
7244	bool MasmParser::lookUpField(StringRef Base, StringRef Member,
7245	AsmFieldInfo &Info) const {
7246	if (Base.empty())
7247	return true;
7248
7249	AsmFieldInfo BaseInfo;
7250	if (Base.contains(C: '.') && !lookUpField(Name: Base, Info&: BaseInfo))
7251	Base = BaseInfo.Type.Name;
7252
7253	auto StructIt = Structs.find(Key: Base.lower());
7254	auto TypeIt = KnownType.find(Key: Base.lower());
7255	if (TypeIt != KnownType.end()) {
7256	StructIt = Structs.find(Key: TypeIt->second.Name.lower());
7257	}
7258	if (StructIt != Structs.end())
7259	return lookUpField(Structure: StructIt->second, Member, Info);
7260
7261	return true;
7262	}
7263
7264	bool MasmParser::lookUpField(const StructInfo &Structure, StringRef Member,
7265	AsmFieldInfo &Info) const {
7266	if (Member.empty()) {
7267	Info.Type.Name = Structure.Name;
7268	Info.Type.Size = Structure.Size;
7269	Info.Type.ElementSize = Structure.Size;
7270	Info.Type.Length = 1;
7271	return false;
7272	}
7273
7274	std::pair<StringRef, StringRef> Split = Member.split(Separator: '.');
7275	const StringRef FieldName = Split.first, FieldMember = Split.second;
7276
7277	auto StructIt = Structs.find(Key: FieldName.lower());
7278	if (StructIt != Structs.end())
7279	return lookUpField(Structure: StructIt->second, Member: FieldMember, Info);
7280
7281	auto FieldIt = Structure.FieldsByName.find(Key: FieldName.lower());
7282	if (FieldIt == Structure.FieldsByName.end())
7283	return true;
7284
7285	const FieldInfo &Field = Structure.Fields[FieldIt->second];
7286	if (FieldMember.empty()) {
7287	Info.Offset += Field.Offset;
7288	Info.Type.Size = Field.SizeOf;
7289	Info.Type.ElementSize = Field.Type;
7290	Info.Type.Length = Field.LengthOf;
7291	if (Field.Contents.FT == FT_STRUCT)
7292	Info.Type.Name = Field.Contents.StructInfo.Structure.Name;
7293	else
7294	Info.Type.Name = "";
7295	return false;
7296	}
7297
7298	if (Field.Contents.FT != FT_STRUCT)
7299	return true;
7300	const StructFieldInfo &StructInfo = Field.Contents.StructInfo;
7301
7302	if (lookUpField(Structure: StructInfo.Structure, Member: FieldMember, Info))
7303	return true;
7304
7305	Info.Offset += Field.Offset;
7306	return false;
7307	}
7308
7309	bool MasmParser::lookUpType(StringRef Name, AsmTypeInfo &Info) const {
7310	unsigned Size = StringSwitch<unsigned>(Name)
7311	.CasesLower(S0: "byte", S1: "db", S2: "sbyte", Value: 1)
7312	.CasesLower(S0: "word", S1: "dw", S2: "sword", Value: 2)
7313	.CasesLower(S0: "dword", S1: "dd", S2: "sdword", Value: 4)
7314	.CasesLower(S0: "fword", S1: "df", Value: 6)
7315	.CasesLower(S0: "qword", S1: "dq", S2: "sqword", Value: 8)
7316	.CaseLower(S: "real4", Value: 4)
7317	.CaseLower(S: "real8", Value: 8)
7318	.CaseLower(S: "real10", Value: 10)
7319	.Default(Value: 0);
7320	if (Size) {
7321	Info.Name = Name;
7322	Info.ElementSize = Size;
7323	Info.Length = 1;
7324	Info.Size = Size;
7325	return false;
7326	}
7327
7328	auto StructIt = Structs.find(Key: Name.lower());
7329	if (StructIt != Structs.end()) {
7330	const StructInfo &Structure = StructIt->second;
7331	Info.Name = Name;
7332	Info.ElementSize = Structure.Size;
7333	Info.Length = 1;
7334	Info.Size = Structure.Size;
7335	return false;
7336	}
7337
7338	return true;
7339	}
7340
7341	bool MasmParser::parseMSInlineAsm(
7342	std::string &AsmString, unsigned &NumOutputs, unsigned &NumInputs,
7343	SmallVectorImpl<std::pair<void *, bool>> &OpDecls,
7344	SmallVectorImpl<std::string> &Constraints,
7345	SmallVectorImpl<std::string> &Clobbers, const MCInstrInfo *MII,
7346	const MCInstPrinter *IP, MCAsmParserSemaCallback &SI) {
7347	SmallVector<void *, 4> InputDecls;
7348	SmallVector<void *, 4> OutputDecls;
7349	SmallVector<bool, 4> InputDeclsAddressOf;
7350	SmallVector<bool, 4> OutputDeclsAddressOf;
7351	SmallVector<std::string, 4> InputConstraints;
7352	SmallVector<std::string, 4> OutputConstraints;
7353	SmallVector<unsigned, 4> ClobberRegs;
7354
7355	SmallVector<AsmRewrite, 4> AsmStrRewrites;
7356
7357	// Prime the lexer.
7358	Lex();
7359
7360	// While we have input, parse each statement.
7361	unsigned InputIdx = 0;
7362	unsigned OutputIdx = 0;
7363	while (getLexer().isNot(K: AsmToken::Eof)) {
7364	// Parse curly braces marking block start/end.
7365	if (parseCurlyBlockScope(AsmStrRewrites))
7366	continue;
7367
7368	ParseStatementInfo Info(&AsmStrRewrites);
7369	bool StatementErr = parseStatement(Info, SI: &SI);
7370
7371	if (StatementErr || Info.ParseError) {
7372	// Emit pending errors if any exist.
7373	printPendingErrors();
7374	return true;
7375	}
7376
7377	// No pending error should exist here.
7378	assert(!hasPendingError() && "unexpected error from parseStatement");
7379
7380	if (Info.Opcode == ~0U)
7381	continue;
7382
7383	const MCInstrDesc &Desc = MII->get(Opcode: Info.Opcode);
7384
7385	// Build the list of clobbers, outputs and inputs.
7386	for (unsigned i = 1, e = Info.ParsedOperands.size(); i != e; ++i) {
7387	MCParsedAsmOperand &Operand = *Info.ParsedOperands[i];
7388
7389	// Register operand.
7390	if (Operand.isReg() && !Operand.needAddressOf() &&
7391	!getTargetParser().OmitRegisterFromClobberLists(RegNo: Operand.getReg())) {
7392	unsigned NumDefs = Desc.getNumDefs();
7393	// Clobber.
7394	if (NumDefs && Operand.getMCOperandNum() < NumDefs)
7395	ClobberRegs.push_back(Elt: Operand.getReg());
7396	continue;
7397	}
7398
7399	// Expr/Input or Output.
7400	StringRef SymName = Operand.getSymName();
7401	if (SymName.empty())
7402	continue;
7403
7404	void *OpDecl = Operand.getOpDecl();
7405	if (!OpDecl)
7406	continue;
7407
7408	StringRef Constraint = Operand.getConstraint();
7409	if (Operand.isImm()) {
7410	// Offset as immediate.
7411	if (Operand.isOffsetOfLocal())
7412	Constraint = "r";
7413	else
7414	Constraint = "i";
7415	}
7416
7417	bool isOutput = (i == 1) && Desc.mayStore();
7418	SMLoc Start = SMLoc::getFromPointer(Ptr: SymName.data());
7419	if (isOutput) {
7420	++InputIdx;
7421	OutputDecls.push_back(Elt: OpDecl);
7422	OutputDeclsAddressOf.push_back(Elt: Operand.needAddressOf());
7423	OutputConstraints.push_back(Elt: ("=" + Constraint).str());
7424	AsmStrRewrites.emplace_back(Args: AOK_Output, Args&: Start, Args: SymName.size());
7425	} else {
7426	InputDecls.push_back(Elt: OpDecl);
7427	InputDeclsAddressOf.push_back(Elt: Operand.needAddressOf());
7428	InputConstraints.push_back(Elt: Constraint.str());
7429	if (Desc.operands()[i - 1].isBranchTarget())
7430	AsmStrRewrites.emplace_back(Args: AOK_CallInput, Args&: Start, Args: SymName.size());
7431	else
7432	AsmStrRewrites.emplace_back(Args: AOK_Input, Args&: Start, Args: SymName.size());
7433	}
7434	}
7435
7436	// Consider implicit defs to be clobbers. Think of cpuid and push.
7437	llvm::append_range(C&: ClobberRegs, R: Desc.implicit_defs());
7438	}
7439
7440	// Set the number of Outputs and Inputs.
7441	NumOutputs = OutputDecls.size();
7442	NumInputs = InputDecls.size();
7443
7444	// Set the unique clobbers.
7445	array_pod_sort(Start: ClobberRegs.begin(), End: ClobberRegs.end());
7446	ClobberRegs.erase(CS: std::unique(first: ClobberRegs.begin(), last: ClobberRegs.end()),
7447	CE: ClobberRegs.end());
7448	Clobbers.assign(NumElts: ClobberRegs.size(), Elt: std::string());
7449	for (unsigned I = 0, E = ClobberRegs.size(); I != E; ++I) {
7450	raw_string_ostream OS(Clobbers[I]);
7451	IP->printRegName(OS, Reg: ClobberRegs[I]);
7452	}
7453
7454	// Merge the various outputs and inputs. Output are expected first.
7455	if (NumOutputs || NumInputs) {
7456	unsigned NumExprs = NumOutputs + NumInputs;
7457	OpDecls.resize(N: NumExprs);
7458	Constraints.resize(N: NumExprs);
7459	for (unsigned i = 0; i < NumOutputs; ++i) {
7460	OpDecls[i] = std::make_pair(x&: OutputDecls[i], y&: OutputDeclsAddressOf[i]);
7461	Constraints[i] = OutputConstraints[i];
7462	}
7463	for (unsigned i = 0, j = NumOutputs; i < NumInputs; ++i, ++j) {
7464	OpDecls[j] = std::make_pair(x&: InputDecls[i], y&: InputDeclsAddressOf[i]);
7465	Constraints[j] = InputConstraints[i];
7466	}
7467	}
7468
7469	// Build the IR assembly string.
7470	std::string AsmStringIR;
7471	raw_string_ostream OS(AsmStringIR);
7472	StringRef ASMString =
7473	SrcMgr.getMemoryBuffer(i: SrcMgr.getMainFileID())->getBuffer();
7474	const char *AsmStart = ASMString.begin();
7475	const char *AsmEnd = ASMString.end();
7476	array_pod_sort(Start: AsmStrRewrites.begin(), End: AsmStrRewrites.end(), Compare: rewritesSort);
7477	for (auto it = AsmStrRewrites.begin(); it != AsmStrRewrites.end(); ++it) {
7478	const AsmRewrite &AR = *it;
7479	// Check if this has already been covered by another rewrite...
7480	if (AR.Done)
7481	continue;
7482	AsmRewriteKind Kind = AR.Kind;
7483
7484	const char *Loc = AR.Loc.getPointer();
7485	assert(Loc >= AsmStart && "Expected Loc to be at or after Start!");
7486
7487	// Emit everything up to the immediate/expression.
7488	if (unsigned Len = Loc - AsmStart)
7489	OS << StringRef(AsmStart, Len);
7490
7491	// Skip the original expression.
7492	if (Kind == AOK_Skip) {
7493	AsmStart = Loc + AR.Len;
7494	continue;
7495	}
7496
7497	unsigned AdditionalSkip = 0;
7498	// Rewrite expressions in $N notation.
7499	switch (Kind) {
7500	default:
7501	break;
7502	case AOK_IntelExpr:
7503	assert(AR.IntelExp.isValid() && "cannot write invalid intel expression");
7504	if (AR.IntelExp.NeedBracs)
7505	OS << "[";
7506	if (AR.IntelExp.hasBaseReg())
7507	OS << AR.IntelExp.BaseReg;
7508	if (AR.IntelExp.hasIndexReg())
7509	OS << (AR.IntelExp.hasBaseReg() ? " + " : "")
7510	<< AR.IntelExp.IndexReg;
7511	if (AR.IntelExp.Scale > 1)
7512	OS << " * $$" << AR.IntelExp.Scale;
7513	if (AR.IntelExp.hasOffset()) {
7514	if (AR.IntelExp.hasRegs())
7515	OS << " + ";
7516	// Fuse this rewrite with a rewrite of the offset name, if present.
7517	StringRef OffsetName = AR.IntelExp.OffsetName;
7518	SMLoc OffsetLoc = SMLoc::getFromPointer(Ptr: AR.IntelExp.OffsetName.data());
7519	size_t OffsetLen = OffsetName.size();
7520	auto rewrite_it = std::find_if(
7521	first: it, last: AsmStrRewrites.end(), pred: [&](const AsmRewrite &FusingAR) {
7522	return FusingAR.Loc == OffsetLoc && FusingAR.Len == OffsetLen &&
7523	(FusingAR.Kind == AOK_Input ||
7524	FusingAR.Kind == AOK_CallInput);
7525	});
7526	if (rewrite_it == AsmStrRewrites.end()) {
7527	OS << "offset " << OffsetName;
7528	} else if (rewrite_it->Kind == AOK_CallInput) {
7529	OS << "${" << InputIdx++ << ":P}";
7530	rewrite_it->Done = true;
7531	} else {
7532	OS << '$' << InputIdx++;
7533	rewrite_it->Done = true;
7534	}
7535	}
7536	if (AR.IntelExp.Imm || AR.IntelExp.emitImm())
7537	OS << (AR.IntelExp.emitImm() ? "$$" : " + $$") << AR.IntelExp.Imm;
7538	if (AR.IntelExp.NeedBracs)
7539	OS << "]";
7540	break;
7541	case AOK_Label:
7542	OS << Ctx.getAsmInfo()->getPrivateLabelPrefix() << AR.Label;
7543	break;
7544	case AOK_Input:
7545	OS << '$' << InputIdx++;
7546	break;
7547	case AOK_CallInput:
7548	OS << "${" << InputIdx++ << ":P}";
7549	break;
7550	case AOK_Output:
7551	OS << '$' << OutputIdx++;
7552	break;
7553	case AOK_SizeDirective:
7554	switch (AR.Val) {
7555	default: break;
7556	case 8: OS << "byte ptr "; break;
7557	case 16: OS << "word ptr "; break;
7558	case 32: OS << "dword ptr "; break;
7559	case 64: OS << "qword ptr "; break;
7560	case 80: OS << "xword ptr "; break;
7561	case 128: OS << "xmmword ptr "; break;
7562	case 256: OS << "ymmword ptr "; break;
7563	}
7564	break;
7565	case AOK_Emit:
7566	OS << ".byte";
7567	break;
7568	case AOK_Align: {
7569	// MS alignment directives are measured in bytes. If the native assembler
7570	// measures alignment in bytes, we can pass it straight through.
7571	OS << ".align";
7572	if (getContext().getAsmInfo()->getAlignmentIsInBytes())
7573	break;
7574
7575	// Alignment is in log2 form, so print that instead and skip the original
7576	// immediate.
7577	unsigned Val = AR.Val;
7578	OS << ' ' << Val;
7579	assert(Val < 10 && "Expected alignment less then 2^10.");
7580	AdditionalSkip = (Val < 4) ? 2 : Val < 7 ? 3 : 4;
7581	break;
7582	}
7583	case AOK_EVEN:
7584	OS << ".even";
7585	break;
7586	case AOK_EndOfStatement:
7587	OS << "\n\t";
7588	break;
7589	}
7590
7591	// Skip the original expression.
7592	AsmStart = Loc + AR.Len + AdditionalSkip;
7593	}
7594
7595	// Emit the remainder of the asm string.
7596	if (AsmStart != AsmEnd)
7597	OS << StringRef(AsmStart, AsmEnd - AsmStart);
7598
7599	AsmString = OS.str();
7600	return false;
7601	}
7602
7603	void MasmParser::initializeBuiltinSymbolMap() {
7604	// Numeric built-ins (supported in all versions)
7605	BuiltinSymbolMap["@version"] = BI_VERSION;
7606	BuiltinSymbolMap["@line"] = BI_LINE;
7607
7608	// Text built-ins (supported in all versions)
7609	BuiltinSymbolMap["@date"] = BI_DATE;
7610	BuiltinSymbolMap["@time"] = BI_TIME;
7611	BuiltinSymbolMap["@filecur"] = BI_FILECUR;
7612	BuiltinSymbolMap["@filename"] = BI_FILENAME;
7613	BuiltinSymbolMap["@curseg"] = BI_CURSEG;
7614
7615	// Some built-ins exist only for MASM32 (32-bit x86)
7616	if (getContext().getSubtargetInfo()->getTargetTriple().getArch() ==
7617	Triple::x86) {
7618	// Numeric built-ins
7619	// BuiltinSymbolMap["@cpu"] = BI_CPU;
7620	// BuiltinSymbolMap["@interface"] = BI_INTERFACE;
7621	// BuiltinSymbolMap["@wordsize"] = BI_WORDSIZE;
7622	// BuiltinSymbolMap["@codesize"] = BI_CODESIZE;
7623	// BuiltinSymbolMap["@datasize"] = BI_DATASIZE;
7624	// BuiltinSymbolMap["@model"] = BI_MODEL;
7625
7626	// Text built-ins
7627	// BuiltinSymbolMap["@code"] = BI_CODE;
7628	// BuiltinSymbolMap["@data"] = BI_DATA;
7629	// BuiltinSymbolMap["@fardata?"] = BI_FARDATA;
7630	// BuiltinSymbolMap["@stack"] = BI_STACK;
7631	}
7632	}
7633
7634	const MCExpr *MasmParser::evaluateBuiltinValue(BuiltinSymbol Symbol,
7635	SMLoc StartLoc) {
7636	switch (Symbol) {
7637	default:
7638	return nullptr;
7639	case BI_VERSION:
7640	// Match a recent version of ML.EXE.
7641	return MCConstantExpr::create(Value: 1427, Ctx&: getContext());
7642	case BI_LINE: {
7643	int64_t Line;
7644	if (ActiveMacros.empty())
7645	Line = SrcMgr.FindLineNumber(Loc: StartLoc, BufferID: CurBuffer);
7646	else
7647	Line = SrcMgr.FindLineNumber(Loc: ActiveMacros.front()->InstantiationLoc,
7648	BufferID: ActiveMacros.front()->ExitBuffer);
7649	return MCConstantExpr::create(Value: Line, Ctx&: getContext());
7650	}
7651	}
7652	llvm_unreachable("unhandled built-in symbol");
7653	}
7654
7655	std::optional<std::string>
7656	MasmParser::evaluateBuiltinTextMacro(BuiltinSymbol Symbol, SMLoc StartLoc) {
7657	switch (Symbol) {
7658	default:
7659	return {};
7660	case BI_DATE: {
7661	// Current local date, formatted MM/DD/YY
7662	char TmpBuffer[sizeof("mm/dd/yy")];
7663	const size_t Len = strftime(s: TmpBuffer, maxsize: sizeof(TmpBuffer), format: "%D", tp: &TM);
7664	return std::string(TmpBuffer, Len);
7665	}
7666	case BI_TIME: {
7667	// Current local time, formatted HH:MM:SS (24-hour clock)
7668	char TmpBuffer[sizeof("hh:mm:ss")];
7669	const size_t Len = strftime(s: TmpBuffer, maxsize: sizeof(TmpBuffer), format: "%T", tp: &TM);
7670	return std::string(TmpBuffer, Len);
7671	}
7672	case BI_FILECUR:
7673	return SrcMgr
7674	.getMemoryBuffer(
7675	i: ActiveMacros.empty() ? CurBuffer : ActiveMacros.front()->ExitBuffer)
7676	->getBufferIdentifier()
7677	.str();
7678	case BI_FILENAME:
7679	return sys::path::stem(path: SrcMgr.getMemoryBuffer(i: SrcMgr.getMainFileID())
7680	->getBufferIdentifier())
7681	.upper();
7682	case BI_CURSEG:
7683	return getStreamer().getCurrentSectionOnly()->getName().str();
7684	}
7685	llvm_unreachable("unhandled built-in symbol");
7686	}
7687
7688	/// Create an MCAsmParser instance.
7689	MCAsmParser *llvm::createMCMasmParser(SourceMgr &SM, MCContext &C,
7690	MCStreamer &Out, const MCAsmInfo &MAI,
7691	struct tm TM, unsigned CB) {
7692	return new MasmParser(SM, C, Out, MAI, TM, CB);
7693	}
7694