Bug Summary

File:lib/MC/MCParser/AsmParser.cpp
Warning:line 3395, column 7
Value stored to 'FileNumber' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name AsmParser.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-config-compatibility-mode=true -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn349319/build-llvm/lib/MC/MCParser -I /build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser -I /build/llvm-toolchain-snapshot-8~svn349319/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn349319/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn349319/build-llvm/lib/MC/MCParser -fdebug-prefix-map=/build/llvm-toolchain-snapshot-8~svn349319=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-12-17-043027-19008-1 -x c++ /build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp -faddrsig
1//===- AsmParser.cpp - Parser for Assembly Files --------------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This class implements the parser for assembly files.
11//
12//===----------------------------------------------------------------------===//
13
14#include "llvm/ADT/APFloat.h"
15#include "llvm/ADT/APInt.h"
16#include "llvm/ADT/ArrayRef.h"
17#include "llvm/ADT/None.h"
18#include "llvm/ADT/STLExtras.h"
19#include "llvm/ADT/SmallString.h"
20#include "llvm/ADT/SmallVector.h"
21#include "llvm/ADT/StringExtras.h"
22#include "llvm/ADT/StringMap.h"
23#include "llvm/ADT/StringRef.h"
24#include "llvm/ADT/Twine.h"
25#include "llvm/BinaryFormat/Dwarf.h"
26#include "llvm/MC/MCAsmInfo.h"
27#include "llvm/MC/MCCodeView.h"
28#include "llvm/MC/MCContext.h"
29#include "llvm/MC/MCDirectives.h"
30#include "llvm/MC/MCDwarf.h"
31#include "llvm/MC/MCExpr.h"
32#include "llvm/MC/MCInstPrinter.h"
33#include "llvm/MC/MCInstrDesc.h"
34#include "llvm/MC/MCInstrInfo.h"
35#include "llvm/MC/MCObjectFileInfo.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/MCAsmParserUtils.h"
42#include "llvm/MC/MCParser/MCParsedAsmOperand.h"
43#include "llvm/MC/MCParser/MCTargetAsmParser.h"
44#include "llvm/MC/MCRegisterInfo.h"
45#include "llvm/MC/MCSection.h"
46#include "llvm/MC/MCStreamer.h"
47#include "llvm/MC/MCSymbol.h"
48#include "llvm/MC/MCTargetOptions.h"
49#include "llvm/MC/MCValue.h"
50#include "llvm/Support/Casting.h"
51#include "llvm/Support/CommandLine.h"
52#include "llvm/Support/ErrorHandling.h"
53#include "llvm/Support/MD5.h"
54#include "llvm/Support/MathExtras.h"
55#include "llvm/Support/MemoryBuffer.h"
56#include "llvm/Support/SMLoc.h"
57#include "llvm/Support/SourceMgr.h"
58#include "llvm/Support/raw_ostream.h"
59#include <algorithm>
60#include <cassert>
61#include <cctype>
62#include <climits>
63#include <cstddef>
64#include <cstdint>
65#include <deque>
66#include <memory>
67#include <sstream>
68#include <string>
69#include <tuple>
70#include <utility>
71#include <vector>
72
73using namespace llvm;
74
75MCAsmParserSemaCallback::~MCAsmParserSemaCallback() = default;
76
77static cl::opt<unsigned> AsmMacroMaxNestingDepth(
78 "asm-macro-max-nesting-depth", cl::init(20), cl::Hidden,
79 cl::desc("The maximum nesting depth allowed for assembly macros."));
80
81namespace {
82
83/// Helper types for tracking macro definitions.
84typedef std::vector<AsmToken> MCAsmMacroArgument;
85typedef std::vector<MCAsmMacroArgument> MCAsmMacroArguments;
86
87/// Helper class for storing information about an active macro
88/// instantiation.
89struct MacroInstantiation {
90 /// The location of the instantiation.
91 SMLoc InstantiationLoc;
92
93 /// The buffer where parsing should resume upon instantiation completion.
94 int ExitBuffer;
95
96 /// The location where parsing should resume upon instantiation completion.
97 SMLoc ExitLoc;
98
99 /// The depth of TheCondStack at the start of the instantiation.
100 size_t CondStackDepth;
101
102public:
103 MacroInstantiation(SMLoc IL, int EB, SMLoc EL, size_t CondStackDepth);
104};
105
106struct ParseStatementInfo {
107 /// The parsed operands from the last parsed statement.
108 SmallVector<std::unique_ptr<MCParsedAsmOperand>, 8> ParsedOperands;
109
110 /// The opcode from the last parsed instruction.
111 unsigned Opcode = ~0U;
112
113 /// Was there an error parsing the inline assembly?
114 bool ParseError = false;
115
116 SmallVectorImpl<AsmRewrite> *AsmRewrites = nullptr;
117
118 ParseStatementInfo() = delete;
119 ParseStatementInfo(SmallVectorImpl<AsmRewrite> *rewrites)
120 : AsmRewrites(rewrites) {}
121};
122
123/// The concrete assembly parser instance.
124class AsmParser : public MCAsmParser {
125private:
126 AsmLexer Lexer;
127 MCContext &Ctx;
128 MCStreamer &Out;
129 const MCAsmInfo &MAI;
130 SourceMgr &SrcMgr;
131 SourceMgr::DiagHandlerTy SavedDiagHandler;
132 void *SavedDiagContext;
133 std::unique_ptr<MCAsmParserExtension> PlatformParser;
134
135 /// This is the current buffer index we're lexing from as managed by the
136 /// SourceMgr object.
137 unsigned CurBuffer;
138
139 AsmCond TheCondState;
140 std::vector<AsmCond> TheCondStack;
141
142 /// maps directive names to handler methods in parser
143 /// extensions. Extensions register themselves in this map by calling
144 /// addDirectiveHandler.
145 StringMap<ExtensionDirectiveHandler> ExtensionDirectiveMap;
146
147 /// Stack of active macro instantiations.
148 std::vector<MacroInstantiation*> ActiveMacros;
149
150 /// List of bodies of anonymous macros.
151 std::deque<MCAsmMacro> MacroLikeBodies;
152
153 /// Boolean tracking whether macro substitution is enabled.
154 unsigned MacrosEnabledFlag : 1;
155
156 /// Keeps track of how many .macro's have been instantiated.
157 unsigned NumOfMacroInstantiations;
158
159 /// The values from the last parsed cpp hash file line comment if any.
160 struct CppHashInfoTy {
161 StringRef Filename;
162 int64_t LineNumber = 0;
163 SMLoc Loc;
164 unsigned Buf = 0;
165 };
166 CppHashInfoTy CppHashInfo;
167
168 /// List of forward directional labels for diagnosis at the end.
169 SmallVector<std::tuple<SMLoc, CppHashInfoTy, MCSymbol *>, 4> DirLabels;
170
171 /// AssemblerDialect. ~OU means unset value and use value provided by MAI.
172 unsigned AssemblerDialect = ~0U;
173
174 /// is Darwin compatibility enabled?
175 bool IsDarwin = false;
176
177 /// Are we parsing ms-style inline assembly?
178 bool ParsingInlineAsm = false;
179
180 /// Did we already inform the user about inconsistent MD5 usage?
181 bool ReportedInconsistentMD5 = false;
182
183 // Is alt macro mode enabled.
184 bool AltMacroMode = false;
185
186public:
187 AsmParser(SourceMgr &SM, MCContext &Ctx, MCStreamer &Out,
188 const MCAsmInfo &MAI, unsigned CB);
189 AsmParser(const AsmParser &) = delete;
190 AsmParser &operator=(const AsmParser &) = delete;
191 ~AsmParser() override;
192
193 bool Run(bool NoInitialTextSection, bool NoFinalize = false) override;
194
195 void addDirectiveHandler(StringRef Directive,
196 ExtensionDirectiveHandler Handler) override {
197 ExtensionDirectiveMap[Directive] = Handler;
198 }
199
200 void addAliasForDirective(StringRef Directive, StringRef Alias) override {
201 DirectiveKindMap[Directive] = DirectiveKindMap[Alias];
202 }
203
204 /// @name MCAsmParser Interface
205 /// {
206
207 SourceMgr &getSourceManager() override { return SrcMgr; }
208 MCAsmLexer &getLexer() override { return Lexer; }
209 MCContext &getContext() override { return Ctx; }
210 MCStreamer &getStreamer() override { return Out; }
211
212 CodeViewContext &getCVContext() { return Ctx.getCVContext(); }
213
214 unsigned getAssemblerDialect() override {
215 if (AssemblerDialect == ~0U)
216 return MAI.getAssemblerDialect();
217 else
218 return AssemblerDialect;
219 }
220 void setAssemblerDialect(unsigned i) override {
221 AssemblerDialect = i;
222 }
223
224 void Note(SMLoc L, const Twine &Msg, SMRange Range = None) override;
225 bool Warning(SMLoc L, const Twine &Msg, SMRange Range = None) override;
226 bool printError(SMLoc L, const Twine &Msg, SMRange Range = None) override;
227
228 const AsmToken &Lex() override;
229
230 void setParsingInlineAsm(bool V) override {
231 ParsingInlineAsm = V;
232 // When parsing MS inline asm, we must lex 0b1101 and 0ABCH as binary and
233 // hex integer literals.
234 Lexer.setLexMasmIntegers(V);
235 }
236 bool isParsingInlineAsm() override { return ParsingInlineAsm; }
237
238 bool parseMSInlineAsm(void *AsmLoc, std::string &AsmString,
239 unsigned &NumOutputs, unsigned &NumInputs,
240 SmallVectorImpl<std::pair<void *,bool>> &OpDecls,
241 SmallVectorImpl<std::string> &Constraints,
242 SmallVectorImpl<std::string> &Clobbers,
243 const MCInstrInfo *MII, const MCInstPrinter *IP,
244 MCAsmParserSemaCallback &SI) override;
245
246 bool parseExpression(const MCExpr *&Res);
247 bool parseExpression(const MCExpr *&Res, SMLoc &EndLoc) override;
248 bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) override;
249 bool parseParenExpression(const MCExpr *&Res, SMLoc &EndLoc) override;
250 bool parseParenExprOfDepth(unsigned ParenDepth, const MCExpr *&Res,
251 SMLoc &EndLoc) override;
252 bool parseAbsoluteExpression(int64_t &Res) override;
253
254 /// Parse a floating point expression using the float \p Semantics
255 /// and set \p Res to the value.
256 bool parseRealValue(const fltSemantics &Semantics, APInt &Res);
257
258 /// Parse an identifier or string (as a quoted identifier)
259 /// and set \p Res to the identifier contents.
260 bool parseIdentifier(StringRef &Res) override;
261 void eatToEndOfStatement() override;
262
263 bool checkForValidSection() override;
264
265 /// }
266
267private:
268 bool parseStatement(ParseStatementInfo &Info,
269 MCAsmParserSemaCallback *SI);
270 bool parseCurlyBlockScope(SmallVectorImpl<AsmRewrite>& AsmStrRewrites);
271 bool parseCppHashLineFilenameComment(SMLoc L);
272
273 void checkForBadMacro(SMLoc DirectiveLoc, StringRef Name, StringRef Body,
274 ArrayRef<MCAsmMacroParameter> Parameters);
275 bool expandMacro(raw_svector_ostream &OS, StringRef Body,
276 ArrayRef<MCAsmMacroParameter> Parameters,
277 ArrayRef<MCAsmMacroArgument> A, bool EnableAtPseudoVariable,
278 SMLoc L);
279
280 /// Are macros enabled in the parser?
281 bool areMacrosEnabled() {return MacrosEnabledFlag;}
282
283 /// Control a flag in the parser that enables or disables macros.
284 void setMacrosEnabled(bool Flag) {MacrosEnabledFlag = Flag;}
285
286 /// Are we inside a macro instantiation?
287 bool isInsideMacroInstantiation() {return !ActiveMacros.empty();}
288
289 /// Handle entry to macro instantiation.
290 ///
291 /// \param M The macro.
292 /// \param NameLoc Instantiation location.
293 bool handleMacroEntry(const MCAsmMacro *M, SMLoc NameLoc);
294
295 /// Handle exit from macro instantiation.
296 void handleMacroExit();
297
298 /// Extract AsmTokens for a macro argument.
299 bool parseMacroArgument(MCAsmMacroArgument &MA, bool Vararg);
300
301 /// Parse all macro arguments for a given macro.
302 bool parseMacroArguments(const MCAsmMacro *M, MCAsmMacroArguments &A);
303
304 void printMacroInstantiations();
305 void printMessage(SMLoc Loc, SourceMgr::DiagKind Kind, const Twine &Msg,
306 SMRange Range = None) const {
307 ArrayRef<SMRange> Ranges(Range);
308 SrcMgr.PrintMessage(Loc, Kind, Msg, Ranges);
309 }
310 static void DiagHandler(const SMDiagnostic &Diag, void *Context);
311
312 /// Should we emit DWARF describing this assembler source? (Returns false if
313 /// the source has .file directives, which means we don't want to generate
314 /// info describing the assembler source itself.)
315 bool enabledGenDwarfForAssembly();
316
317 /// Enter the specified file. This returns true on failure.
318 bool enterIncludeFile(const std::string &Filename);
319
320 /// Process the specified file for the .incbin directive.
321 /// This returns true on failure.
322 bool processIncbinFile(const std::string &Filename, int64_t Skip = 0,
323 const MCExpr *Count = nullptr, SMLoc Loc = SMLoc());
324
325 /// Reset the current lexer position to that given by \p Loc. The
326 /// current token is not set; clients should ensure Lex() is called
327 /// subsequently.
328 ///
329 /// \param InBuffer If not 0, should be the known buffer id that contains the
330 /// location.
331 void jumpToLoc(SMLoc Loc, unsigned InBuffer = 0);
332
333 /// Parse up to the end of statement and a return the contents from the
334 /// current token until the end of the statement; the current token on exit
335 /// will be either the EndOfStatement or EOF.
336 StringRef parseStringToEndOfStatement() override;
337
338 /// Parse until the end of a statement or a comma is encountered,
339 /// return the contents from the current token up to the end or comma.
340 StringRef parseStringToComma();
341
342 bool parseAssignment(StringRef Name, bool allow_redef,
343 bool NoDeadStrip = false);
344
345 unsigned getBinOpPrecedence(AsmToken::TokenKind K,
346 MCBinaryExpr::Opcode &Kind);
347
348 bool parseBinOpRHS(unsigned Precedence, const MCExpr *&Res, SMLoc &EndLoc);
349 bool parseParenExpr(const MCExpr *&Res, SMLoc &EndLoc);
350 bool parseBracketExpr(const MCExpr *&Res, SMLoc &EndLoc);
351
352 bool parseRegisterOrRegisterNumber(int64_t &Register, SMLoc DirectiveLoc);
353
354 bool parseCVFunctionId(int64_t &FunctionId, StringRef DirectiveName);
355 bool parseCVFileId(int64_t &FileId, StringRef DirectiveName);
356
357 // Generic (target and platform independent) directive parsing.
358 enum DirectiveKind {
359 DK_NO_DIRECTIVE, // Placeholder
360 DK_SET,
361 DK_EQU,
362 DK_EQUIV,
363 DK_ASCII,
364 DK_ASCIZ,
365 DK_STRING,
366 DK_BYTE,
367 DK_SHORT,
368 DK_RELOC,
369 DK_VALUE,
370 DK_2BYTE,
371 DK_LONG,
372 DK_INT,
373 DK_4BYTE,
374 DK_QUAD,
375 DK_8BYTE,
376 DK_OCTA,
377 DK_DC,
378 DK_DC_A,
379 DK_DC_B,
380 DK_DC_D,
381 DK_DC_L,
382 DK_DC_S,
383 DK_DC_W,
384 DK_DC_X,
385 DK_DCB,
386 DK_DCB_B,
387 DK_DCB_D,
388 DK_DCB_L,
389 DK_DCB_S,
390 DK_DCB_W,
391 DK_DCB_X,
392 DK_DS,
393 DK_DS_B,
394 DK_DS_D,
395 DK_DS_L,
396 DK_DS_P,
397 DK_DS_S,
398 DK_DS_W,
399 DK_DS_X,
400 DK_SINGLE,
401 DK_FLOAT,
402 DK_DOUBLE,
403 DK_ALIGN,
404 DK_ALIGN32,
405 DK_BALIGN,
406 DK_BALIGNW,
407 DK_BALIGNL,
408 DK_P2ALIGN,
409 DK_P2ALIGNW,
410 DK_P2ALIGNL,
411 DK_ORG,
412 DK_FILL,
413 DK_ENDR,
414 DK_BUNDLE_ALIGN_MODE,
415 DK_BUNDLE_LOCK,
416 DK_BUNDLE_UNLOCK,
417 DK_ZERO,
418 DK_EXTERN,
419 DK_GLOBL,
420 DK_GLOBAL,
421 DK_LAZY_REFERENCE,
422 DK_NO_DEAD_STRIP,
423 DK_SYMBOL_RESOLVER,
424 DK_PRIVATE_EXTERN,
425 DK_REFERENCE,
426 DK_WEAK_DEFINITION,
427 DK_WEAK_REFERENCE,
428 DK_WEAK_DEF_CAN_BE_HIDDEN,
429 DK_COMM,
430 DK_COMMON,
431 DK_LCOMM,
432 DK_ABORT,
433 DK_INCLUDE,
434 DK_INCBIN,
435 DK_CODE16,
436 DK_CODE16GCC,
437 DK_REPT,
438 DK_IRP,
439 DK_IRPC,
440 DK_IF,
441 DK_IFEQ,
442 DK_IFGE,
443 DK_IFGT,
444 DK_IFLE,
445 DK_IFLT,
446 DK_IFNE,
447 DK_IFB,
448 DK_IFNB,
449 DK_IFC,
450 DK_IFEQS,
451 DK_IFNC,
452 DK_IFNES,
453 DK_IFDEF,
454 DK_IFNDEF,
455 DK_IFNOTDEF,
456 DK_ELSEIF,
457 DK_ELSE,
458 DK_ENDIF,
459 DK_SPACE,
460 DK_SKIP,
461 DK_FILE,
462 DK_LINE,
463 DK_LOC,
464 DK_STABS,
465 DK_CV_FILE,
466 DK_CV_FUNC_ID,
467 DK_CV_INLINE_SITE_ID,
468 DK_CV_LOC,
469 DK_CV_LINETABLE,
470 DK_CV_INLINE_LINETABLE,
471 DK_CV_DEF_RANGE,
472 DK_CV_STRINGTABLE,
473 DK_CV_STRING,
474 DK_CV_FILECHECKSUMS,
475 DK_CV_FILECHECKSUM_OFFSET,
476 DK_CV_FPO_DATA,
477 DK_CFI_SECTIONS,
478 DK_CFI_STARTPROC,
479 DK_CFI_ENDPROC,
480 DK_CFI_DEF_CFA,
481 DK_CFI_DEF_CFA_OFFSET,
482 DK_CFI_ADJUST_CFA_OFFSET,
483 DK_CFI_DEF_CFA_REGISTER,
484 DK_CFI_OFFSET,
485 DK_CFI_REL_OFFSET,
486 DK_CFI_PERSONALITY,
487 DK_CFI_LSDA,
488 DK_CFI_REMEMBER_STATE,
489 DK_CFI_RESTORE_STATE,
490 DK_CFI_SAME_VALUE,
491 DK_CFI_RESTORE,
492 DK_CFI_ESCAPE,
493 DK_CFI_RETURN_COLUMN,
494 DK_CFI_SIGNAL_FRAME,
495 DK_CFI_UNDEFINED,
496 DK_CFI_REGISTER,
497 DK_CFI_WINDOW_SAVE,
498 DK_MACROS_ON,
499 DK_MACROS_OFF,
500 DK_ALTMACRO,
501 DK_NOALTMACRO,
502 DK_MACRO,
503 DK_EXITM,
504 DK_ENDM,
505 DK_ENDMACRO,
506 DK_PURGEM,
507 DK_SLEB128,
508 DK_ULEB128,
509 DK_ERR,
510 DK_ERROR,
511 DK_WARNING,
512 DK_PRINT,
513 DK_ADDRSIG,
514 DK_ADDRSIG_SYM,
515 DK_END
516 };
517
518 /// Maps directive name --> DirectiveKind enum, for
519 /// directives parsed by this class.
520 StringMap<DirectiveKind> DirectiveKindMap;
521
522 // ".ascii", ".asciz", ".string"
523 bool parseDirectiveAscii(StringRef IDVal, bool ZeroTerminated);
524 bool parseDirectiveReloc(SMLoc DirectiveLoc); // ".reloc"
525 bool parseDirectiveValue(StringRef IDVal,
526 unsigned Size); // ".byte", ".long", ...
527 bool parseDirectiveOctaValue(StringRef IDVal); // ".octa", ...
528 bool parseDirectiveRealValue(StringRef IDVal,
529 const fltSemantics &); // ".single", ...
530 bool parseDirectiveFill(); // ".fill"
531 bool parseDirectiveZero(); // ".zero"
532 // ".set", ".equ", ".equiv"
533 bool parseDirectiveSet(StringRef IDVal, bool allow_redef);
534 bool parseDirectiveOrg(); // ".org"
535 // ".align{,32}", ".p2align{,w,l}"
536 bool parseDirectiveAlign(bool IsPow2, unsigned ValueSize);
537
538 // ".file", ".line", ".loc", ".stabs"
539 bool parseDirectiveFile(SMLoc DirectiveLoc);
540 bool parseDirectiveLine();
541 bool parseDirectiveLoc();
542 bool parseDirectiveStabs();
543
544 // ".cv_file", ".cv_func_id", ".cv_inline_site_id", ".cv_loc", ".cv_linetable",
545 // ".cv_inline_linetable", ".cv_def_range", ".cv_string"
546 bool parseDirectiveCVFile();
547 bool parseDirectiveCVFuncId();
548 bool parseDirectiveCVInlineSiteId();
549 bool parseDirectiveCVLoc();
550 bool parseDirectiveCVLinetable();
551 bool parseDirectiveCVInlineLinetable();
552 bool parseDirectiveCVDefRange();
553 bool parseDirectiveCVString();
554 bool parseDirectiveCVStringTable();
555 bool parseDirectiveCVFileChecksums();
556 bool parseDirectiveCVFileChecksumOffset();
557 bool parseDirectiveCVFPOData();
558
559 // .cfi directives
560 bool parseDirectiveCFIRegister(SMLoc DirectiveLoc);
561 bool parseDirectiveCFIWindowSave();
562 bool parseDirectiveCFISections();
563 bool parseDirectiveCFIStartProc();
564 bool parseDirectiveCFIEndProc();
565 bool parseDirectiveCFIDefCfaOffset();
566 bool parseDirectiveCFIDefCfa(SMLoc DirectiveLoc);
567 bool parseDirectiveCFIAdjustCfaOffset();
568 bool parseDirectiveCFIDefCfaRegister(SMLoc DirectiveLoc);
569 bool parseDirectiveCFIOffset(SMLoc DirectiveLoc);
570 bool parseDirectiveCFIRelOffset(SMLoc DirectiveLoc);
571 bool parseDirectiveCFIPersonalityOrLsda(bool IsPersonality);
572 bool parseDirectiveCFIRememberState();
573 bool parseDirectiveCFIRestoreState();
574 bool parseDirectiveCFISameValue(SMLoc DirectiveLoc);
575 bool parseDirectiveCFIRestore(SMLoc DirectiveLoc);
576 bool parseDirectiveCFIEscape();
577 bool parseDirectiveCFIReturnColumn(SMLoc DirectiveLoc);
578 bool parseDirectiveCFISignalFrame();
579 bool parseDirectiveCFIUndefined(SMLoc DirectiveLoc);
580
581 // macro directives
582 bool parseDirectivePurgeMacro(SMLoc DirectiveLoc);
583 bool parseDirectiveExitMacro(StringRef Directive);
584 bool parseDirectiveEndMacro(StringRef Directive);
585 bool parseDirectiveMacro(SMLoc DirectiveLoc);
586 bool parseDirectiveMacrosOnOff(StringRef Directive);
587 // alternate macro mode directives
588 bool parseDirectiveAltmacro(StringRef Directive);
589 // ".bundle_align_mode"
590 bool parseDirectiveBundleAlignMode();
591 // ".bundle_lock"
592 bool parseDirectiveBundleLock();
593 // ".bundle_unlock"
594 bool parseDirectiveBundleUnlock();
595
596 // ".space", ".skip"
597 bool parseDirectiveSpace(StringRef IDVal);
598
599 // ".dcb"
600 bool parseDirectiveDCB(StringRef IDVal, unsigned Size);
601 bool parseDirectiveRealDCB(StringRef IDVal, const fltSemantics &);
602 // ".ds"
603 bool parseDirectiveDS(StringRef IDVal, unsigned Size);
604
605 // .sleb128 (Signed=true) and .uleb128 (Signed=false)
606 bool parseDirectiveLEB128(bool Signed);
607
608 /// Parse a directive like ".globl" which
609 /// accepts a single symbol (which should be a label or an external).
610 bool parseDirectiveSymbolAttribute(MCSymbolAttr Attr);
611
612 bool parseDirectiveComm(bool IsLocal); // ".comm" and ".lcomm"
613
614 bool parseDirectiveAbort(); // ".abort"
615 bool parseDirectiveInclude(); // ".include"
616 bool parseDirectiveIncbin(); // ".incbin"
617
618 // ".if", ".ifeq", ".ifge", ".ifgt" , ".ifle", ".iflt" or ".ifne"
619 bool parseDirectiveIf(SMLoc DirectiveLoc, DirectiveKind DirKind);
620 // ".ifb" or ".ifnb", depending on ExpectBlank.
621 bool parseDirectiveIfb(SMLoc DirectiveLoc, bool ExpectBlank);
622 // ".ifc" or ".ifnc", depending on ExpectEqual.
623 bool parseDirectiveIfc(SMLoc DirectiveLoc, bool ExpectEqual);
624 // ".ifeqs" or ".ifnes", depending on ExpectEqual.
625 bool parseDirectiveIfeqs(SMLoc DirectiveLoc, bool ExpectEqual);
626 // ".ifdef" or ".ifndef", depending on expect_defined
627 bool parseDirectiveIfdef(SMLoc DirectiveLoc, bool expect_defined);
628 bool parseDirectiveElseIf(SMLoc DirectiveLoc); // ".elseif"
629 bool parseDirectiveElse(SMLoc DirectiveLoc); // ".else"
630 bool parseDirectiveEndIf(SMLoc DirectiveLoc); // .endif
631 bool parseEscapedString(std::string &Data) override;
632
633 const MCExpr *applyModifierToExpr(const MCExpr *E,
634 MCSymbolRefExpr::VariantKind Variant);
635
636 // Macro-like directives
637 MCAsmMacro *parseMacroLikeBody(SMLoc DirectiveLoc);
638 void instantiateMacroLikeBody(MCAsmMacro *M, SMLoc DirectiveLoc,
639 raw_svector_ostream &OS);
640 bool parseDirectiveRept(SMLoc DirectiveLoc, StringRef Directive);
641 bool parseDirectiveIrp(SMLoc DirectiveLoc); // ".irp"
642 bool parseDirectiveIrpc(SMLoc DirectiveLoc); // ".irpc"
643 bool parseDirectiveEndr(SMLoc DirectiveLoc); // ".endr"
644
645 // "_emit" or "__emit"
646 bool parseDirectiveMSEmit(SMLoc DirectiveLoc, ParseStatementInfo &Info,
647 size_t Len);
648
649 // "align"
650 bool parseDirectiveMSAlign(SMLoc DirectiveLoc, ParseStatementInfo &Info);
651
652 // "end"
653 bool parseDirectiveEnd(SMLoc DirectiveLoc);
654
655 // ".err" or ".error"
656 bool parseDirectiveError(SMLoc DirectiveLoc, bool WithMessage);
657
658 // ".warning"
659 bool parseDirectiveWarning(SMLoc DirectiveLoc);
660
661 // .print <double-quotes-string>
662 bool parseDirectivePrint(SMLoc DirectiveLoc);
663
664 // Directives to support address-significance tables.
665 bool parseDirectiveAddrsig();
666 bool parseDirectiveAddrsigSym();
667
668 void initializeDirectiveKindMap();
669};
670
671} // end anonymous namespace
672
673namespace llvm {
674
675extern MCAsmParserExtension *createDarwinAsmParser();
676extern MCAsmParserExtension *createELFAsmParser();
677extern MCAsmParserExtension *createCOFFAsmParser();
678extern MCAsmParserExtension *createWasmAsmParser();
679
680} // end namespace llvm
681
682enum { DEFAULT_ADDRSPACE = 0 };
683
684AsmParser::AsmParser(SourceMgr &SM, MCContext &Ctx, MCStreamer &Out,
685 const MCAsmInfo &MAI, unsigned CB = 0)
686 : Lexer(MAI), Ctx(Ctx), Out(Out), MAI(MAI), SrcMgr(SM),
687 CurBuffer(CB ? CB : SM.getMainFileID()), MacrosEnabledFlag(true) {
688 HadError = false;
689 // Save the old handler.
690 SavedDiagHandler = SrcMgr.getDiagHandler();
691 SavedDiagContext = SrcMgr.getDiagContext();
692 // Set our own handler which calls the saved handler.
693 SrcMgr.setDiagHandler(DiagHandler, this);
694 Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer());
695
696 // Initialize the platform / file format parser.
697 switch (Ctx.getObjectFileInfo()->getObjectFileType()) {
698 case MCObjectFileInfo::IsCOFF:
699 PlatformParser.reset(createCOFFAsmParser());
700 break;
701 case MCObjectFileInfo::IsMachO:
702 PlatformParser.reset(createDarwinAsmParser());
703 IsDarwin = true;
704 break;
705 case MCObjectFileInfo::IsELF:
706 PlatformParser.reset(createELFAsmParser());
707 break;
708 case MCObjectFileInfo::IsWasm:
709 PlatformParser.reset(createWasmAsmParser());
710 break;
711 }
712
713 PlatformParser->Initialize(*this);
714 initializeDirectiveKindMap();
715
716 NumOfMacroInstantiations = 0;
717}
718
719AsmParser::~AsmParser() {
720 assert((HadError || ActiveMacros.empty()) &&(((HadError || ActiveMacros.empty()) && "Unexpected active macro instantiation!"
) ? static_cast<void> (0) : __assert_fail ("(HadError || ActiveMacros.empty()) && \"Unexpected active macro instantiation!\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 721, __PRETTY_FUNCTION__))
721 "Unexpected active macro instantiation!")(((HadError || ActiveMacros.empty()) && "Unexpected active macro instantiation!"
) ? static_cast<void> (0) : __assert_fail ("(HadError || ActiveMacros.empty()) && \"Unexpected active macro instantiation!\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 721, __PRETTY_FUNCTION__))
;
722
723 // Restore the saved diagnostics handler and context for use during
724 // finalization.
725 SrcMgr.setDiagHandler(SavedDiagHandler, SavedDiagContext);
726}
727
728void AsmParser::printMacroInstantiations() {
729 // Print the active macro instantiation stack.
730 for (std::vector<MacroInstantiation *>::const_reverse_iterator
731 it = ActiveMacros.rbegin(),
732 ie = ActiveMacros.rend();
733 it != ie; ++it)
734 printMessage((*it)->InstantiationLoc, SourceMgr::DK_Note,
735 "while in macro instantiation");
736}
737
738void AsmParser::Note(SMLoc L, const Twine &Msg, SMRange Range) {
739 printPendingErrors();
740 printMessage(L, SourceMgr::DK_Note, Msg, Range);
741 printMacroInstantiations();
742}
743
744bool AsmParser::Warning(SMLoc L, const Twine &Msg, SMRange Range) {
745 if(getTargetParser().getTargetOptions().MCNoWarn)
746 return false;
747 if (getTargetParser().getTargetOptions().MCFatalWarnings)
748 return Error(L, Msg, Range);
749 printMessage(L, SourceMgr::DK_Warning, Msg, Range);
750 printMacroInstantiations();
751 return false;
752}
753
754bool AsmParser::printError(SMLoc L, const Twine &Msg, SMRange Range) {
755 HadError = true;
756 printMessage(L, SourceMgr::DK_Error, Msg, Range);
757 printMacroInstantiations();
758 return true;
759}
760
761bool AsmParser::enterIncludeFile(const std::string &Filename) {
762 std::string IncludedFile;
763 unsigned NewBuf =
764 SrcMgr.AddIncludeFile(Filename, Lexer.getLoc(), IncludedFile);
765 if (!NewBuf)
766 return true;
767
768 CurBuffer = NewBuf;
769 Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer());
770 return false;
771}
772
773/// Process the specified .incbin file by searching for it in the include paths
774/// then just emitting the byte contents of the file to the streamer. This
775/// returns true on failure.
776bool AsmParser::processIncbinFile(const std::string &Filename, int64_t Skip,
777 const MCExpr *Count, SMLoc Loc) {
778 std::string IncludedFile;
779 unsigned NewBuf =
780 SrcMgr.AddIncludeFile(Filename, Lexer.getLoc(), IncludedFile);
781 if (!NewBuf)
782 return true;
783
784 // Pick up the bytes from the file and emit them.
785 StringRef Bytes = SrcMgr.getMemoryBuffer(NewBuf)->getBuffer();
786 Bytes = Bytes.drop_front(Skip);
787 if (Count) {
788 int64_t Res;
789 if (!Count->evaluateAsAbsolute(Res, getStreamer().getAssemblerPtr()))
790 return Error(Loc, "expected absolute expression");
791 if (Res < 0)
792 return Warning(Loc, "negative count has no effect");
793 Bytes = Bytes.take_front(Res);
794 }
795 getStreamer().EmitBytes(Bytes);
796 return false;
797}
798
799void AsmParser::jumpToLoc(SMLoc Loc, unsigned InBuffer) {
800 CurBuffer = InBuffer ? InBuffer : SrcMgr.FindBufferContainingLoc(Loc);
801 Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer(),
802 Loc.getPointer());
803}
804
805const AsmToken &AsmParser::Lex() {
806 if (Lexer.getTok().is(AsmToken::Error))
807 Error(Lexer.getErrLoc(), Lexer.getErr());
808
809 // if it's a end of statement with a comment in it
810 if (getTok().is(AsmToken::EndOfStatement)) {
811 // if this is a line comment output it.
812 if (!getTok().getString().empty() && getTok().getString().front() != '\n' &&
813 getTok().getString().front() != '\r' && MAI.preserveAsmComments())
814 Out.addExplicitComment(Twine(getTok().getString()));
815 }
816
817 const AsmToken *tok = &Lexer.Lex();
818
819 // Parse comments here to be deferred until end of next statement.
820 while (tok->is(AsmToken::Comment)) {
821 if (MAI.preserveAsmComments())
822 Out.addExplicitComment(Twine(tok->getString()));
823 tok = &Lexer.Lex();
824 }
825
826 if (tok->is(AsmToken::Eof)) {
827 // If this is the end of an included file, pop the parent file off the
828 // include stack.
829 SMLoc ParentIncludeLoc = SrcMgr.getParentIncludeLoc(CurBuffer);
830 if (ParentIncludeLoc != SMLoc()) {
831 jumpToLoc(ParentIncludeLoc);
832 return Lex();
833 }
834 }
835
836 return *tok;
837}
838
839bool AsmParser::enabledGenDwarfForAssembly() {
840 // Check whether the user specified -g.
841 if (!getContext().getGenDwarfForAssembly())
842 return false;
843 // If we haven't encountered any .file directives (which would imply that
844 // the assembler source was produced with debug info already) then emit one
845 // describing the assembler source file itself.
846 if (getContext().getGenDwarfFileNumber() == 0)
847 getContext().setGenDwarfFileNumber(getStreamer().EmitDwarfFileDirective(
848 0, StringRef(), getContext().getMainFileName()));
849 return true;
850}
851
852bool AsmParser::Run(bool NoInitialTextSection, bool NoFinalize) {
853 // Create the initial section, if requested.
854 if (!NoInitialTextSection)
855 Out.InitSections(false);
856
857 // Prime the lexer.
858 Lex();
859
860 HadError = false;
861 AsmCond StartingCondState = TheCondState;
862 SmallVector<AsmRewrite, 4> AsmStrRewrites;
863
864 // If we are generating dwarf for assembly source files save the initial text
865 // section. (Don't use enabledGenDwarfForAssembly() here, as we aren't
866 // emitting any actual debug info yet and haven't had a chance to parse any
867 // embedded .file directives.)
868 if (getContext().getGenDwarfForAssembly()) {
869 MCSection *Sec = getStreamer().getCurrentSectionOnly();
870 if (!Sec->getBeginSymbol()) {
871 MCSymbol *SectionStartSym = getContext().createTempSymbol();
872 getStreamer().EmitLabel(SectionStartSym);
873 Sec->setBeginSymbol(SectionStartSym);
874 }
875 bool InsertResult = getContext().addGenDwarfSection(Sec);
876 assert(InsertResult && ".text section should not have debug info yet")((InsertResult && ".text section should not have debug info yet"
) ? static_cast<void> (0) : __assert_fail ("InsertResult && \".text section should not have debug info yet\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 876, __PRETTY_FUNCTION__))
;
877 (void)InsertResult;
878 }
879
880 // While we have input, parse each statement.
881 while (Lexer.isNot(AsmToken::Eof)) {
882 ParseStatementInfo Info(&AsmStrRewrites);
883 if (!parseStatement(Info, nullptr))
884 continue;
885
886 // If we have a Lexer Error we are on an Error Token. Load in Lexer Error
887 // for printing ErrMsg via Lex() only if no (presumably better) parser error
888 // exists.
889 if (!hasPendingError() && Lexer.getTok().is(AsmToken::Error)) {
890 Lex();
891 }
892
893 // parseStatement returned true so may need to emit an error.
894 printPendingErrors();
895
896 // Skipping to the next line if needed.
897 if (!getLexer().isAtStartOfStatement())
898 eatToEndOfStatement();
899 }
900
901 // All errors should have been emitted.
902 assert(!hasPendingError() && "unexpected error from parseStatement")((!hasPendingError() && "unexpected error from parseStatement"
) ? static_cast<void> (0) : __assert_fail ("!hasPendingError() && \"unexpected error from parseStatement\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 902, __PRETTY_FUNCTION__))
;
903
904 getTargetParser().flushPendingInstructions(getStreamer());
905
906 if (TheCondState.TheCond != StartingCondState.TheCond ||
907 TheCondState.Ignore != StartingCondState.Ignore)
908 printError(getTok().getLoc(), "unmatched .ifs or .elses");
909 // Check to see there are no empty DwarfFile slots.
910 const auto &LineTables = getContext().getMCDwarfLineTables();
911 if (!LineTables.empty()) {
912 unsigned Index = 0;
913 for (const auto &File : LineTables.begin()->second.getMCDwarfFiles()) {
914 if (File.Name.empty() && Index != 0)
915 printError(getTok().getLoc(), "unassigned file number: " +
916 Twine(Index) +
917 " for .file directives");
918 ++Index;
919 }
920 }
921
922 // Check to see that all assembler local symbols were actually defined.
923 // Targets that don't do subsections via symbols may not want this, though,
924 // so conservatively exclude them. Only do this if we're finalizing, though,
925 // as otherwise we won't necessarilly have seen everything yet.
926 if (!NoFinalize) {
927 if (MAI.hasSubsectionsViaSymbols()) {
928 for (const auto &TableEntry : getContext().getSymbols()) {
929 MCSymbol *Sym = TableEntry.getValue();
930 // Variable symbols may not be marked as defined, so check those
931 // explicitly. If we know it's a variable, we have a definition for
932 // the purposes of this check.
933 if (Sym->isTemporary() && !Sym->isVariable() && !Sym->isDefined())
934 // FIXME: We would really like to refer back to where the symbol was
935 // first referenced for a source location. We need to add something
936 // to track that. Currently, we just point to the end of the file.
937 printError(getTok().getLoc(), "assembler local symbol '" +
938 Sym->getName() + "' not defined");
939 }
940 }
941
942 // Temporary symbols like the ones for directional jumps don't go in the
943 // symbol table. They also need to be diagnosed in all (final) cases.
944 for (std::tuple<SMLoc, CppHashInfoTy, MCSymbol *> &LocSym : DirLabels) {
945 if (std::get<2>(LocSym)->isUndefined()) {
946 // Reset the state of any "# line file" directives we've seen to the
947 // context as it was at the diagnostic site.
948 CppHashInfo = std::get<1>(LocSym);
949 printError(std::get<0>(LocSym), "directional label undefined");
950 }
951 }
952 }
953
954 // Finalize the output stream if there are no errors and if the client wants
955 // us to.
956 if (!HadError && !NoFinalize)
957 Out.Finish();
958
959 return HadError || getContext().hadError();
960}
961
962bool AsmParser::checkForValidSection() {
963 if (!ParsingInlineAsm && !getStreamer().getCurrentSectionOnly()) {
964 Out.InitSections(false);
965 return Error(getTok().getLoc(),
966 "expected section directive before assembly directive");
967 }
968 return false;
969}
970
971/// Throw away the rest of the line for testing purposes.
972void AsmParser::eatToEndOfStatement() {
973 while (Lexer.isNot(AsmToken::EndOfStatement) && Lexer.isNot(AsmToken::Eof))
974 Lexer.Lex();
975
976 // Eat EOL.
977 if (Lexer.is(AsmToken::EndOfStatement))
978 Lexer.Lex();
979}
980
981StringRef AsmParser::parseStringToEndOfStatement() {
982 const char *Start = getTok().getLoc().getPointer();
983
984 while (Lexer.isNot(AsmToken::EndOfStatement) && Lexer.isNot(AsmToken::Eof))
985 Lexer.Lex();
986
987 const char *End = getTok().getLoc().getPointer();
988 return StringRef(Start, End - Start);
989}
990
991StringRef AsmParser::parseStringToComma() {
992 const char *Start = getTok().getLoc().getPointer();
993
994 while (Lexer.isNot(AsmToken::EndOfStatement) &&
995 Lexer.isNot(AsmToken::Comma) && Lexer.isNot(AsmToken::Eof))
996 Lexer.Lex();
997
998 const char *End = getTok().getLoc().getPointer();
999 return StringRef(Start, End - Start);
1000}
1001
1002/// Parse a paren expression and return it.
1003/// NOTE: This assumes the leading '(' has already been consumed.
1004///
1005/// parenexpr ::= expr)
1006///
1007bool AsmParser::parseParenExpr(const MCExpr *&Res, SMLoc &EndLoc) {
1008 if (parseExpression(Res))
1009 return true;
1010 if (Lexer.isNot(AsmToken::RParen))
1011 return TokError("expected ')' in parentheses expression");
1012 EndLoc = Lexer.getTok().getEndLoc();
1013 Lex();
1014 return false;
1015}
1016
1017/// Parse a bracket expression and return it.
1018/// NOTE: This assumes the leading '[' has already been consumed.
1019///
1020/// bracketexpr ::= expr]
1021///
1022bool AsmParser::parseBracketExpr(const MCExpr *&Res, SMLoc &EndLoc) {
1023 if (parseExpression(Res))
1024 return true;
1025 EndLoc = getTok().getEndLoc();
1026 if (parseToken(AsmToken::RBrac, "expected ']' in brackets expression"))
1027 return true;
1028 return false;
1029}
1030
1031/// Parse a primary expression and return it.
1032/// primaryexpr ::= (parenexpr
1033/// primaryexpr ::= symbol
1034/// primaryexpr ::= number
1035/// primaryexpr ::= '.'
1036/// primaryexpr ::= ~,+,- primaryexpr
1037bool AsmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) {
1038 SMLoc FirstTokenLoc = getLexer().getLoc();
1039 AsmToken::TokenKind FirstTokenKind = Lexer.getKind();
1040 switch (FirstTokenKind) {
1041 default:
1042 return TokError("unknown token in expression");
1043 // If we have an error assume that we've already handled it.
1044 case AsmToken::Error:
1045 return true;
1046 case AsmToken::Exclaim:
1047 Lex(); // Eat the operator.
1048 if (parsePrimaryExpr(Res, EndLoc))
1049 return true;
1050 Res = MCUnaryExpr::createLNot(Res, getContext(), FirstTokenLoc);
1051 return false;
1052 case AsmToken::Dollar:
1053 case AsmToken::At:
1054 case AsmToken::String:
1055 case AsmToken::Identifier: {
1056 StringRef Identifier;
1057 if (parseIdentifier(Identifier)) {
1058 // We may have failed but $ may be a valid token.
1059 if (getTok().is(AsmToken::Dollar)) {
1060 if (Lexer.getMAI().getDollarIsPC()) {
1061 Lex();
1062 // This is a '$' reference, which references the current PC. Emit a
1063 // temporary label to the streamer and refer to it.
1064 MCSymbol *Sym = Ctx.createTempSymbol();
1065 Out.EmitLabel(Sym);
1066 Res = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None,
1067 getContext());
1068 EndLoc = FirstTokenLoc;
1069 return false;
1070 }
1071 return Error(FirstTokenLoc, "invalid token in expression");
1072 }
1073 }
1074 // Parse symbol variant
1075 std::pair<StringRef, StringRef> Split;
1076 if (!MAI.useParensForSymbolVariant()) {
1077 if (FirstTokenKind == AsmToken::String) {
1078 if (Lexer.is(AsmToken::At)) {
1079 Lex(); // eat @
1080 SMLoc AtLoc = getLexer().getLoc();
1081 StringRef VName;
1082 if (parseIdentifier(VName))
1083 return Error(AtLoc, "expected symbol variant after '@'");
1084
1085 Split = std::make_pair(Identifier, VName);
1086 }
1087 } else {
1088 Split = Identifier.split('@');
1089 }
1090 } else if (Lexer.is(AsmToken::LParen)) {
1091 Lex(); // eat '('.
1092 StringRef VName;
1093 parseIdentifier(VName);
1094 // eat ')'.
1095 if (parseToken(AsmToken::RParen,
1096 "unexpected token in variant, expected ')'"))
1097 return true;
1098 Split = std::make_pair(Identifier, VName);
1099 }
1100
1101 EndLoc = SMLoc::getFromPointer(Identifier.end());
1102
1103 // This is a symbol reference.
1104 StringRef SymbolName = Identifier;
1105 if (SymbolName.empty())
1106 return Error(getLexer().getLoc(), "expected a symbol reference");
1107
1108 MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
1109
1110 // Lookup the symbol variant if used.
1111 if (!Split.second.empty()) {
1112 Variant = MCSymbolRefExpr::getVariantKindForName(Split.second);
1113 if (Variant != MCSymbolRefExpr::VK_Invalid) {
1114 SymbolName = Split.first;
1115 } else if (MAI.doesAllowAtInName() && !MAI.useParensForSymbolVariant()) {
1116 Variant = MCSymbolRefExpr::VK_None;
1117 } else {
1118 return Error(SMLoc::getFromPointer(Split.second.begin()),
1119 "invalid variant '" + Split.second + "'");
1120 }
1121 }
1122
1123 MCSymbol *Sym = getContext().getOrCreateSymbol(SymbolName);
1124
1125 // If this is an absolute variable reference, substitute it now to preserve
1126 // semantics in the face of reassignment.
1127 if (Sym->isVariable()) {
1128 auto V = Sym->getVariableValue(/*SetUsed*/ false);
1129 bool DoInline = isa<MCConstantExpr>(V) && !Variant;
1130 if (auto TV = dyn_cast<MCTargetExpr>(V))
1131 DoInline = TV->inlineAssignedExpr();
1132 if (DoInline) {
1133 if (Variant)
1134 return Error(EndLoc, "unexpected modifier on variable reference");
1135 Res = Sym->getVariableValue(/*SetUsed*/ false);
1136 return false;
1137 }
1138 }
1139
1140 // Otherwise create a symbol ref.
1141 Res = MCSymbolRefExpr::create(Sym, Variant, getContext(), FirstTokenLoc);
1142 return false;
1143 }
1144 case AsmToken::BigNum:
1145 return TokError("literal value out of range for directive");
1146 case AsmToken::Integer: {
1147 SMLoc Loc = getTok().getLoc();
1148 int64_t IntVal = getTok().getIntVal();
1149 Res = MCConstantExpr::create(IntVal, getContext());
1150 EndLoc = Lexer.getTok().getEndLoc();
1151 Lex(); // Eat token.
1152 // Look for 'b' or 'f' following an Integer as a directional label
1153 if (Lexer.getKind() == AsmToken::Identifier) {
1154 StringRef IDVal = getTok().getString();
1155 // Lookup the symbol variant if used.
1156 std::pair<StringRef, StringRef> Split = IDVal.split('@');
1157 MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
1158 if (Split.first.size() != IDVal.size()) {
1159 Variant = MCSymbolRefExpr::getVariantKindForName(Split.second);
1160 if (Variant == MCSymbolRefExpr::VK_Invalid)
1161 return TokError("invalid variant '" + Split.second + "'");
1162 IDVal = Split.first;
1163 }
1164 if (IDVal == "f" || IDVal == "b") {
1165 MCSymbol *Sym =
1166 Ctx.getDirectionalLocalSymbol(IntVal, IDVal == "b");
1167 Res = MCSymbolRefExpr::create(Sym, Variant, getContext());
1168 if (IDVal == "b" && Sym->isUndefined())
1169 return Error(Loc, "directional label undefined");
1170 DirLabels.push_back(std::make_tuple(Loc, CppHashInfo, Sym));
1171 EndLoc = Lexer.getTok().getEndLoc();
1172 Lex(); // Eat identifier.
1173 }
1174 }
1175 return false;
1176 }
1177 case AsmToken::Real: {
1178 APFloat RealVal(APFloat::IEEEdouble(), getTok().getString());
1179 uint64_t IntVal = RealVal.bitcastToAPInt().getZExtValue();
1180 Res = MCConstantExpr::create(IntVal, getContext());
1181 EndLoc = Lexer.getTok().getEndLoc();
1182 Lex(); // Eat token.
1183 return false;
1184 }
1185 case AsmToken::Dot: {
1186 // This is a '.' reference, which references the current PC. Emit a
1187 // temporary label to the streamer and refer to it.
1188 MCSymbol *Sym = Ctx.createTempSymbol();
1189 Out.EmitLabel(Sym);
1190 Res = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext());
1191 EndLoc = Lexer.getTok().getEndLoc();
1192 Lex(); // Eat identifier.
1193 return false;
1194 }
1195 case AsmToken::LParen:
1196 Lex(); // Eat the '('.
1197 return parseParenExpr(Res, EndLoc);
1198 case AsmToken::LBrac:
1199 if (!PlatformParser->HasBracketExpressions())
1200 return TokError("brackets expression not supported on this target");
1201 Lex(); // Eat the '['.
1202 return parseBracketExpr(Res, EndLoc);
1203 case AsmToken::Minus:
1204 Lex(); // Eat the operator.
1205 if (parsePrimaryExpr(Res, EndLoc))
1206 return true;
1207 Res = MCUnaryExpr::createMinus(Res, getContext(), FirstTokenLoc);
1208 return false;
1209 case AsmToken::Plus:
1210 Lex(); // Eat the operator.
1211 if (parsePrimaryExpr(Res, EndLoc))
1212 return true;
1213 Res = MCUnaryExpr::createPlus(Res, getContext(), FirstTokenLoc);
1214 return false;
1215 case AsmToken::Tilde:
1216 Lex(); // Eat the operator.
1217 if (parsePrimaryExpr(Res, EndLoc))
1218 return true;
1219 Res = MCUnaryExpr::createNot(Res, getContext(), FirstTokenLoc);
1220 return false;
1221 // MIPS unary expression operators. The lexer won't generate these tokens if
1222 // MCAsmInfo::HasMipsExpressions is false for the target.
1223 case AsmToken::PercentCall16:
1224 case AsmToken::PercentCall_Hi:
1225 case AsmToken::PercentCall_Lo:
1226 case AsmToken::PercentDtprel_Hi:
1227 case AsmToken::PercentDtprel_Lo:
1228 case AsmToken::PercentGot:
1229 case AsmToken::PercentGot_Disp:
1230 case AsmToken::PercentGot_Hi:
1231 case AsmToken::PercentGot_Lo:
1232 case AsmToken::PercentGot_Ofst:
1233 case AsmToken::PercentGot_Page:
1234 case AsmToken::PercentGottprel:
1235 case AsmToken::PercentGp_Rel:
1236 case AsmToken::PercentHi:
1237 case AsmToken::PercentHigher:
1238 case AsmToken::PercentHighest:
1239 case AsmToken::PercentLo:
1240 case AsmToken::PercentNeg:
1241 case AsmToken::PercentPcrel_Hi:
1242 case AsmToken::PercentPcrel_Lo:
1243 case AsmToken::PercentTlsgd:
1244 case AsmToken::PercentTlsldm:
1245 case AsmToken::PercentTprel_Hi:
1246 case AsmToken::PercentTprel_Lo:
1247 Lex(); // Eat the operator.
1248 if (Lexer.isNot(AsmToken::LParen))
1249 return TokError("expected '(' after operator");
1250 Lex(); // Eat the operator.
1251 if (parseExpression(Res, EndLoc))
1252 return true;
1253 if (Lexer.isNot(AsmToken::RParen))
1254 return TokError("expected ')'");
1255 Lex(); // Eat the operator.
1256 Res = getTargetParser().createTargetUnaryExpr(Res, FirstTokenKind, Ctx);
1257 return !Res;
1258 }
1259}
1260
1261bool AsmParser::parseExpression(const MCExpr *&Res) {
1262 SMLoc EndLoc;
1263 return parseExpression(Res, EndLoc);
1264}
1265
1266const MCExpr *
1267AsmParser::applyModifierToExpr(const MCExpr *E,
1268 MCSymbolRefExpr::VariantKind Variant) {
1269 // Ask the target implementation about this expression first.
1270 const MCExpr *NewE = getTargetParser().applyModifierToExpr(E, Variant, Ctx);
1271 if (NewE)
1272 return NewE;
1273 // Recurse over the given expression, rebuilding it to apply the given variant
1274 // if there is exactly one symbol.
1275 switch (E->getKind()) {
1276 case MCExpr::Target:
1277 case MCExpr::Constant:
1278 return nullptr;
1279
1280 case MCExpr::SymbolRef: {
1281 const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(E);
1282
1283 if (SRE->getKind() != MCSymbolRefExpr::VK_None) {
1284 TokError("invalid variant on expression '" + getTok().getIdentifier() +
1285 "' (already modified)");
1286 return E;
1287 }
1288
1289 return MCSymbolRefExpr::create(&SRE->getSymbol(), Variant, getContext());
1290 }
1291
1292 case MCExpr::Unary: {
1293 const MCUnaryExpr *UE = cast<MCUnaryExpr>(E);
1294 const MCExpr *Sub = applyModifierToExpr(UE->getSubExpr(), Variant);
1295 if (!Sub)
1296 return nullptr;
1297 return MCUnaryExpr::create(UE->getOpcode(), Sub, getContext());
1298 }
1299
1300 case MCExpr::Binary: {
1301 const MCBinaryExpr *BE = cast<MCBinaryExpr>(E);
1302 const MCExpr *LHS = applyModifierToExpr(BE->getLHS(), Variant);
1303 const MCExpr *RHS = applyModifierToExpr(BE->getRHS(), Variant);
1304
1305 if (!LHS && !RHS)
1306 return nullptr;
1307
1308 if (!LHS)
1309 LHS = BE->getLHS();
1310 if (!RHS)
1311 RHS = BE->getRHS();
1312
1313 return MCBinaryExpr::create(BE->getOpcode(), LHS, RHS, getContext());
1314 }
1315 }
1316
1317 llvm_unreachable("Invalid expression kind!")::llvm::llvm_unreachable_internal("Invalid expression kind!",
"/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 1317)
;
1318}
1319
1320/// This function checks if the next token is <string> type or arithmetic.
1321/// string that begin with character '<' must end with character '>'.
1322/// otherwise it is arithmetics.
1323/// If the function returns a 'true' value,
1324/// the End argument will be filled with the last location pointed to the '>'
1325/// character.
1326
1327/// There is a gap between the AltMacro's documentation and the single quote
1328/// implementation. GCC does not fully support this feature and so we will not
1329/// support it.
1330/// TODO: Adding single quote as a string.
1331static bool isAltmacroString(SMLoc &StrLoc, SMLoc &EndLoc) {
1332 assert((StrLoc.getPointer() != nullptr) &&(((StrLoc.getPointer() != nullptr) && "Argument to the function cannot be a NULL value"
) ? static_cast<void> (0) : __assert_fail ("(StrLoc.getPointer() != nullptr) && \"Argument to the function cannot be a NULL value\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 1333, __PRETTY_FUNCTION__))
1333 "Argument to the function cannot be a NULL value")(((StrLoc.getPointer() != nullptr) && "Argument to the function cannot be a NULL value"
) ? static_cast<void> (0) : __assert_fail ("(StrLoc.getPointer() != nullptr) && \"Argument to the function cannot be a NULL value\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 1333, __PRETTY_FUNCTION__))
;
1334 const char *CharPtr = StrLoc.getPointer();
1335 while ((*CharPtr != '>') && (*CharPtr != '\n') && (*CharPtr != '\r') &&
1336 (*CharPtr != '\0')) {
1337 if (*CharPtr == '!')
1338 CharPtr++;
1339 CharPtr++;
1340 }
1341 if (*CharPtr == '>') {
1342 EndLoc = StrLoc.getFromPointer(CharPtr + 1);
1343 return true;
1344 }
1345 return false;
1346}
1347
1348/// creating a string without the escape characters '!'.
1349static std::string altMacroString(StringRef AltMacroStr) {
1350 std::string Res;
1351 for (size_t Pos = 0; Pos < AltMacroStr.size(); Pos++) {
1352 if (AltMacroStr[Pos] == '!')
1353 Pos++;
1354 Res += AltMacroStr[Pos];
1355 }
1356 return Res;
1357}
1358
1359/// Parse an expression and return it.
1360///
1361/// expr ::= expr &&,|| expr -> lowest.
1362/// expr ::= expr |,^,&,! expr
1363/// expr ::= expr ==,!=,<>,<,<=,>,>= expr
1364/// expr ::= expr <<,>> expr
1365/// expr ::= expr +,- expr
1366/// expr ::= expr *,/,% expr -> highest.
1367/// expr ::= primaryexpr
1368///
1369bool AsmParser::parseExpression(const MCExpr *&Res, SMLoc &EndLoc) {
1370 // Parse the expression.
1371 Res = nullptr;
1372 if (getTargetParser().parsePrimaryExpr(Res, EndLoc) ||
1373 parseBinOpRHS(1, Res, EndLoc))
1374 return true;
1375
1376 // As a special case, we support 'a op b @ modifier' by rewriting the
1377 // expression to include the modifier. This is inefficient, but in general we
1378 // expect users to use 'a@modifier op b'.
1379 if (Lexer.getKind() == AsmToken::At) {
1380 Lex();
1381
1382 if (Lexer.isNot(AsmToken::Identifier))
1383 return TokError("unexpected symbol modifier following '@'");
1384
1385 MCSymbolRefExpr::VariantKind Variant =
1386 MCSymbolRefExpr::getVariantKindForName(getTok().getIdentifier());
1387 if (Variant == MCSymbolRefExpr::VK_Invalid)
1388 return TokError("invalid variant '" + getTok().getIdentifier() + "'");
1389
1390 const MCExpr *ModifiedRes = applyModifierToExpr(Res, Variant);
1391 if (!ModifiedRes) {
1392 return TokError("invalid modifier '" + getTok().getIdentifier() +
1393 "' (no symbols present)");
1394 }
1395
1396 Res = ModifiedRes;
1397 Lex();
1398 }
1399
1400 // Try to constant fold it up front, if possible. Do not exploit
1401 // assembler here.
1402 int64_t Value;
1403 if (Res->evaluateAsAbsolute(Value))
1404 Res = MCConstantExpr::create(Value, getContext());
1405
1406 return false;
1407}
1408
1409bool AsmParser::parseParenExpression(const MCExpr *&Res, SMLoc &EndLoc) {
1410 Res = nullptr;
1411 return parseParenExpr(Res, EndLoc) || parseBinOpRHS(1, Res, EndLoc);
1412}
1413
1414bool AsmParser::parseParenExprOfDepth(unsigned ParenDepth, const MCExpr *&Res,
1415 SMLoc &EndLoc) {
1416 if (parseParenExpr(Res, EndLoc))
1417 return true;
1418
1419 for (; ParenDepth > 0; --ParenDepth) {
1420 if (parseBinOpRHS(1, Res, EndLoc))
1421 return true;
1422
1423 // We don't Lex() the last RParen.
1424 // This is the same behavior as parseParenExpression().
1425 if (ParenDepth - 1 > 0) {
1426 EndLoc = getTok().getEndLoc();
1427 if (parseToken(AsmToken::RParen,
1428 "expected ')' in parentheses expression"))
1429 return true;
1430 }
1431 }
1432 return false;
1433}
1434
1435bool AsmParser::parseAbsoluteExpression(int64_t &Res) {
1436 const MCExpr *Expr;
1437
1438 SMLoc StartLoc = Lexer.getLoc();
1439 if (parseExpression(Expr))
1440 return true;
1441
1442 if (!Expr->evaluateAsAbsolute(Res, getStreamer().getAssemblerPtr()))
1443 return Error(StartLoc, "expected absolute expression");
1444
1445 return false;
1446}
1447
1448static unsigned getDarwinBinOpPrecedence(AsmToken::TokenKind K,
1449 MCBinaryExpr::Opcode &Kind,
1450 bool ShouldUseLogicalShr) {
1451 switch (K) {
1452 default:
1453 return 0; // not a binop.
1454
1455 // Lowest Precedence: &&, ||
1456 case AsmToken::AmpAmp:
1457 Kind = MCBinaryExpr::LAnd;
1458 return 1;
1459 case AsmToken::PipePipe:
1460 Kind = MCBinaryExpr::LOr;
1461 return 1;
1462
1463 // Low Precedence: |, &, ^
1464 //
1465 // FIXME: gas seems to support '!' as an infix operator?
1466 case AsmToken::Pipe:
1467 Kind = MCBinaryExpr::Or;
1468 return 2;
1469 case AsmToken::Caret:
1470 Kind = MCBinaryExpr::Xor;
1471 return 2;
1472 case AsmToken::Amp:
1473 Kind = MCBinaryExpr::And;
1474 return 2;
1475
1476 // Low Intermediate Precedence: ==, !=, <>, <, <=, >, >=
1477 case AsmToken::EqualEqual:
1478 Kind = MCBinaryExpr::EQ;
1479 return 3;
1480 case AsmToken::ExclaimEqual:
1481 case AsmToken::LessGreater:
1482 Kind = MCBinaryExpr::NE;
1483 return 3;
1484 case AsmToken::Less:
1485 Kind = MCBinaryExpr::LT;
1486 return 3;
1487 case AsmToken::LessEqual:
1488 Kind = MCBinaryExpr::LTE;
1489 return 3;
1490 case AsmToken::Greater:
1491 Kind = MCBinaryExpr::GT;
1492 return 3;
1493 case AsmToken::GreaterEqual:
1494 Kind = MCBinaryExpr::GTE;
1495 return 3;
1496
1497 // Intermediate Precedence: <<, >>
1498 case AsmToken::LessLess:
1499 Kind = MCBinaryExpr::Shl;
1500 return 4;
1501 case AsmToken::GreaterGreater:
1502 Kind = ShouldUseLogicalShr ? MCBinaryExpr::LShr : MCBinaryExpr::AShr;
1503 return 4;
1504
1505 // High Intermediate Precedence: +, -
1506 case AsmToken::Plus:
1507 Kind = MCBinaryExpr::Add;
1508 return 5;
1509 case AsmToken::Minus:
1510 Kind = MCBinaryExpr::Sub;
1511 return 5;
1512
1513 // Highest Precedence: *, /, %
1514 case AsmToken::Star:
1515 Kind = MCBinaryExpr::Mul;
1516 return 6;
1517 case AsmToken::Slash:
1518 Kind = MCBinaryExpr::Div;
1519 return 6;
1520 case AsmToken::Percent:
1521 Kind = MCBinaryExpr::Mod;
1522 return 6;
1523 }
1524}
1525
1526static unsigned getGNUBinOpPrecedence(AsmToken::TokenKind K,
1527 MCBinaryExpr::Opcode &Kind,
1528 bool ShouldUseLogicalShr) {
1529 switch (K) {
1530 default:
1531 return 0; // not a binop.
1532
1533 // Lowest Precedence: &&, ||
1534 case AsmToken::AmpAmp:
1535 Kind = MCBinaryExpr::LAnd;
1536 return 2;
1537 case AsmToken::PipePipe:
1538 Kind = MCBinaryExpr::LOr;
1539 return 1;
1540
1541 // Low Precedence: ==, !=, <>, <, <=, >, >=
1542 case AsmToken::EqualEqual:
1543 Kind = MCBinaryExpr::EQ;
1544 return 3;
1545 case AsmToken::ExclaimEqual:
1546 case AsmToken::LessGreater:
1547 Kind = MCBinaryExpr::NE;
1548 return 3;
1549 case AsmToken::Less:
1550 Kind = MCBinaryExpr::LT;
1551 return 3;
1552 case AsmToken::LessEqual:
1553 Kind = MCBinaryExpr::LTE;
1554 return 3;
1555 case AsmToken::Greater:
1556 Kind = MCBinaryExpr::GT;
1557 return 3;
1558 case AsmToken::GreaterEqual:
1559 Kind = MCBinaryExpr::GTE;
1560 return 3;
1561
1562 // Low Intermediate Precedence: +, -
1563 case AsmToken::Plus:
1564 Kind = MCBinaryExpr::Add;
1565 return 4;
1566 case AsmToken::Minus:
1567 Kind = MCBinaryExpr::Sub;
1568 return 4;
1569
1570 // High Intermediate Precedence: |, &, ^
1571 //
1572 // FIXME: gas seems to support '!' as an infix operator?
1573 case AsmToken::Pipe:
1574 Kind = MCBinaryExpr::Or;
1575 return 5;
1576 case AsmToken::Caret:
1577 Kind = MCBinaryExpr::Xor;
1578 return 5;
1579 case AsmToken::Amp:
1580 Kind = MCBinaryExpr::And;
1581 return 5;
1582
1583 // Highest Precedence: *, /, %, <<, >>
1584 case AsmToken::Star:
1585 Kind = MCBinaryExpr::Mul;
1586 return 6;
1587 case AsmToken::Slash:
1588 Kind = MCBinaryExpr::Div;
1589 return 6;
1590 case AsmToken::Percent:
1591 Kind = MCBinaryExpr::Mod;
1592 return 6;
1593 case AsmToken::LessLess:
1594 Kind = MCBinaryExpr::Shl;
1595 return 6;
1596 case AsmToken::GreaterGreater:
1597 Kind = ShouldUseLogicalShr ? MCBinaryExpr::LShr : MCBinaryExpr::AShr;
1598 return 6;
1599 }
1600}
1601
1602unsigned AsmParser::getBinOpPrecedence(AsmToken::TokenKind K,
1603 MCBinaryExpr::Opcode &Kind) {
1604 bool ShouldUseLogicalShr = MAI.shouldUseLogicalShr();
1605 return IsDarwin ? getDarwinBinOpPrecedence(K, Kind, ShouldUseLogicalShr)
1606 : getGNUBinOpPrecedence(K, Kind, ShouldUseLogicalShr);
1607}
1608
1609/// Parse all binary operators with precedence >= 'Precedence'.
1610/// Res contains the LHS of the expression on input.
1611bool AsmParser::parseBinOpRHS(unsigned Precedence, const MCExpr *&Res,
1612 SMLoc &EndLoc) {
1613 SMLoc StartLoc = Lexer.getLoc();
1614 while (true) {
1615 MCBinaryExpr::Opcode Kind = MCBinaryExpr::Add;
1616 unsigned TokPrec = getBinOpPrecedence(Lexer.getKind(), Kind);
1617
1618 // If the next token is lower precedence than we are allowed to eat, return
1619 // successfully with what we ate already.
1620 if (TokPrec < Precedence)
1621 return false;
1622
1623 Lex();
1624
1625 // Eat the next primary expression.
1626 const MCExpr *RHS;
1627 if (getTargetParser().parsePrimaryExpr(RHS, EndLoc))
1628 return true;
1629
1630 // If BinOp binds less tightly with RHS than the operator after RHS, let
1631 // the pending operator take RHS as its LHS.
1632 MCBinaryExpr::Opcode Dummy;
1633 unsigned NextTokPrec = getBinOpPrecedence(Lexer.getKind(), Dummy);
1634 if (TokPrec < NextTokPrec && parseBinOpRHS(TokPrec + 1, RHS, EndLoc))
1635 return true;
1636
1637 // Merge LHS and RHS according to operator.
1638 Res = MCBinaryExpr::create(Kind, Res, RHS, getContext(), StartLoc);
1639 }
1640}
1641
1642/// ParseStatement:
1643/// ::= EndOfStatement
1644/// ::= Label* Directive ...Operands... EndOfStatement
1645/// ::= Label* Identifier OperandList* EndOfStatement
1646bool AsmParser::parseStatement(ParseStatementInfo &Info,
1647 MCAsmParserSemaCallback *SI) {
1648 assert(!hasPendingError() && "parseStatement started with pending error")((!hasPendingError() && "parseStatement started with pending error"
) ? static_cast<void> (0) : __assert_fail ("!hasPendingError() && \"parseStatement started with pending error\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 1648, __PRETTY_FUNCTION__))
;
1649 // Eat initial spaces and comments
1650 while (Lexer.is(AsmToken::Space))
1651 Lex();
1652 if (Lexer.is(AsmToken::EndOfStatement)) {
1653 // if this is a line comment we can drop it safely
1654 if (getTok().getString().empty() || getTok().getString().front() == '\r' ||
1655 getTok().getString().front() == '\n')
1656 Out.AddBlankLine();
1657 Lex();
1658 return false;
1659 }
1660 // Statements always start with an identifier.
1661 AsmToken ID = getTok();
1662 SMLoc IDLoc = ID.getLoc();
1663 StringRef IDVal;
1664 int64_t LocalLabelVal = -1;
1665 if (Lexer.is(AsmToken::HashDirective))
1666 return parseCppHashLineFilenameComment(IDLoc);
1667 // Allow an integer followed by a ':' as a directional local label.
1668 if (Lexer.is(AsmToken::Integer)) {
1669 LocalLabelVal = getTok().getIntVal();
1670 if (LocalLabelVal < 0) {
1671 if (!TheCondState.Ignore) {
1672 Lex(); // always eat a token
1673 return Error(IDLoc, "unexpected token at start of statement");
1674 }
1675 IDVal = "";
1676 } else {
1677 IDVal = getTok().getString();
1678 Lex(); // Consume the integer token to be used as an identifier token.
1679 if (Lexer.getKind() != AsmToken::Colon) {
1680 if (!TheCondState.Ignore) {
1681 Lex(); // always eat a token
1682 return Error(IDLoc, "unexpected token at start of statement");
1683 }
1684 }
1685 }
1686 } else if (Lexer.is(AsmToken::Dot)) {
1687 // Treat '.' as a valid identifier in this context.
1688 Lex();
1689 IDVal = ".";
1690 } else if (Lexer.is(AsmToken::LCurly)) {
1691 // Treat '{' as a valid identifier in this context.
1692 Lex();
1693 IDVal = "{";
1694
1695 } else if (Lexer.is(AsmToken::RCurly)) {
1696 // Treat '}' as a valid identifier in this context.
1697 Lex();
1698 IDVal = "}";
1699 } else if (Lexer.is(AsmToken::Star) &&
1700 getTargetParser().starIsStartOfStatement()) {
1701 // Accept '*' as a valid start of statement.
1702 Lex();
1703 IDVal = "*";
1704 } else if (parseIdentifier(IDVal)) {
1705 if (!TheCondState.Ignore) {
1706 Lex(); // always eat a token
1707 return Error(IDLoc, "unexpected token at start of statement");
1708 }
1709 IDVal = "";
1710 }
1711
1712 // Handle conditional assembly here before checking for skipping. We
1713 // have to do this so that .endif isn't skipped in a ".if 0" block for
1714 // example.
1715 StringMap<DirectiveKind>::const_iterator DirKindIt =
1716 DirectiveKindMap.find(IDVal);
1717 DirectiveKind DirKind = (DirKindIt == DirectiveKindMap.end())
1718 ? DK_NO_DIRECTIVE
1719 : DirKindIt->getValue();
1720 switch (DirKind) {
1721 default:
1722 break;
1723 case DK_IF:
1724 case DK_IFEQ:
1725 case DK_IFGE:
1726 case DK_IFGT:
1727 case DK_IFLE:
1728 case DK_IFLT:
1729 case DK_IFNE:
1730 return parseDirectiveIf(IDLoc, DirKind);
1731 case DK_IFB:
1732 return parseDirectiveIfb(IDLoc, true);
1733 case DK_IFNB:
1734 return parseDirectiveIfb(IDLoc, false);
1735 case DK_IFC:
1736 return parseDirectiveIfc(IDLoc, true);
1737 case DK_IFEQS:
1738 return parseDirectiveIfeqs(IDLoc, true);
1739 case DK_IFNC:
1740 return parseDirectiveIfc(IDLoc, false);
1741 case DK_IFNES:
1742 return parseDirectiveIfeqs(IDLoc, false);
1743 case DK_IFDEF:
1744 return parseDirectiveIfdef(IDLoc, true);
1745 case DK_IFNDEF:
1746 case DK_IFNOTDEF:
1747 return parseDirectiveIfdef(IDLoc, false);
1748 case DK_ELSEIF:
1749 return parseDirectiveElseIf(IDLoc);
1750 case DK_ELSE:
1751 return parseDirectiveElse(IDLoc);
1752 case DK_ENDIF:
1753 return parseDirectiveEndIf(IDLoc);
1754 }
1755
1756 // Ignore the statement if in the middle of inactive conditional
1757 // (e.g. ".if 0").
1758 if (TheCondState.Ignore) {
1759 eatToEndOfStatement();
1760 return false;
1761 }
1762
1763 // FIXME: Recurse on local labels?
1764
1765 // See what kind of statement we have.
1766 switch (Lexer.getKind()) {
1767 case AsmToken::Colon: {
1768 if (!getTargetParser().isLabel(ID))
1769 break;
1770 if (checkForValidSection())
1771 return true;
1772
1773 // identifier ':' -> Label.
1774 Lex();
1775
1776 // Diagnose attempt to use '.' as a label.
1777 if (IDVal == ".")
1778 return Error(IDLoc, "invalid use of pseudo-symbol '.' as a label");
1779
1780 // Diagnose attempt to use a variable as a label.
1781 //
1782 // FIXME: Diagnostics. Note the location of the definition as a label.
1783 // FIXME: This doesn't diagnose assignment to a symbol which has been
1784 // implicitly marked as external.
1785 MCSymbol *Sym;
1786 if (LocalLabelVal == -1) {
1787 if (ParsingInlineAsm && SI) {
1788 StringRef RewrittenLabel =
1789 SI->LookupInlineAsmLabel(IDVal, getSourceManager(), IDLoc, true);
1790 assert(!RewrittenLabel.empty() &&((!RewrittenLabel.empty() && "We should have an internal name here."
) ? static_cast<void> (0) : __assert_fail ("!RewrittenLabel.empty() && \"We should have an internal name here.\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 1791, __PRETTY_FUNCTION__))
1791 "We should have an internal name here.")((!RewrittenLabel.empty() && "We should have an internal name here."
) ? static_cast<void> (0) : __assert_fail ("!RewrittenLabel.empty() && \"We should have an internal name here.\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 1791, __PRETTY_FUNCTION__))
;
1792 Info.AsmRewrites->emplace_back(AOK_Label, IDLoc, IDVal.size(),
1793 RewrittenLabel);
1794 IDVal = RewrittenLabel;
1795 }
1796 Sym = getContext().getOrCreateSymbol(IDVal);
1797 } else
1798 Sym = Ctx.createDirectionalLocalSymbol(LocalLabelVal);
1799 // End of Labels should be treated as end of line for lexing
1800 // purposes but that information is not available to the Lexer who
1801 // does not understand Labels. This may cause us to see a Hash
1802 // here instead of a preprocessor line comment.
1803 if (getTok().is(AsmToken::Hash)) {
1804 StringRef CommentStr = parseStringToEndOfStatement();
1805 Lexer.Lex();
1806 Lexer.UnLex(AsmToken(AsmToken::EndOfStatement, CommentStr));
1807 }
1808
1809 // Consume any end of statement token, if present, to avoid spurious
1810 // AddBlankLine calls().
1811 if (getTok().is(AsmToken::EndOfStatement)) {
1812 Lex();
1813 }
1814
1815 getTargetParser().doBeforeLabelEmit(Sym);
1816
1817 // Emit the label.
1818 if (!getTargetParser().isParsingInlineAsm())
1819 Out.EmitLabel(Sym, IDLoc);
1820
1821 // If we are generating dwarf for assembly source files then gather the
1822 // info to make a dwarf label entry for this label if needed.
1823 if (enabledGenDwarfForAssembly())
1824 MCGenDwarfLabelEntry::Make(Sym, &getStreamer(), getSourceManager(),
1825 IDLoc);
1826
1827 getTargetParser().onLabelParsed(Sym);
1828
1829 return false;
1830 }
1831
1832 case AsmToken::Equal:
1833 if (!getTargetParser().equalIsAsmAssignment())
1834 break;
1835 // identifier '=' ... -> assignment statement
1836 Lex();
1837
1838 return parseAssignment(IDVal, true);
1839
1840 default: // Normal instruction or directive.
1841 break;
1842 }
1843
1844 // If macros are enabled, check to see if this is a macro instantiation.
1845 if (areMacrosEnabled())
1846 if (const MCAsmMacro *M = getContext().lookupMacro(IDVal)) {
1847 return handleMacroEntry(M, IDLoc);
1848 }
1849
1850 // Otherwise, we have a normal instruction or directive.
1851
1852 // Directives start with "."
1853 if (IDVal.startswith(".") && IDVal != ".") {
1854 // There are several entities interested in parsing directives:
1855 //
1856 // 1. The target-specific assembly parser. Some directives are target
1857 // specific or may potentially behave differently on certain targets.
1858 // 2. Asm parser extensions. For example, platform-specific parsers
1859 // (like the ELF parser) register themselves as extensions.
1860 // 3. The generic directive parser implemented by this class. These are
1861 // all the directives that behave in a target and platform independent
1862 // manner, or at least have a default behavior that's shared between
1863 // all targets and platforms.
1864
1865 getTargetParser().flushPendingInstructions(getStreamer());
1866
1867 SMLoc StartTokLoc = getTok().getLoc();
1868 bool TPDirectiveReturn = getTargetParser().ParseDirective(ID);
1869
1870 if (hasPendingError())
1871 return true;
1872 // Currently the return value should be true if we are
1873 // uninterested but as this is at odds with the standard parsing
1874 // convention (return true = error) we have instances of a parsed
1875 // directive that fails returning true as an error. Catch these
1876 // cases as best as possible errors here.
1877 if (TPDirectiveReturn && StartTokLoc != getTok().getLoc())
1878 return true;
1879 // Return if we did some parsing or believe we succeeded.
1880 if (!TPDirectiveReturn || StartTokLoc != getTok().getLoc())
1881 return false;
1882
1883 // Next, check the extension directive map to see if any extension has
1884 // registered itself to parse this directive.
1885 std::pair<MCAsmParserExtension *, DirectiveHandler> Handler =
1886 ExtensionDirectiveMap.lookup(IDVal);
1887 if (Handler.first)
1888 return (*Handler.second)(Handler.first, IDVal, IDLoc);
1889
1890 // Finally, if no one else is interested in this directive, it must be
1891 // generic and familiar to this class.
1892 switch (DirKind) {
1893 default:
1894 break;
1895 case DK_SET:
1896 case DK_EQU:
1897 return parseDirectiveSet(IDVal, true);
1898 case DK_EQUIV:
1899 return parseDirectiveSet(IDVal, false);
1900 case DK_ASCII:
1901 return parseDirectiveAscii(IDVal, false);
1902 case DK_ASCIZ:
1903 case DK_STRING:
1904 return parseDirectiveAscii(IDVal, true);
1905 case DK_BYTE:
1906 case DK_DC_B:
1907 return parseDirectiveValue(IDVal, 1);
1908 case DK_DC:
1909 case DK_DC_W:
1910 case DK_SHORT:
1911 case DK_VALUE:
1912 case DK_2BYTE:
1913 return parseDirectiveValue(IDVal, 2);
1914 case DK_LONG:
1915 case DK_INT:
1916 case DK_4BYTE:
1917 case DK_DC_L:
1918 return parseDirectiveValue(IDVal, 4);
1919 case DK_QUAD:
1920 case DK_8BYTE:
1921 return parseDirectiveValue(IDVal, 8);
1922 case DK_DC_A:
1923 return parseDirectiveValue(
1924 IDVal, getContext().getAsmInfo()->getCodePointerSize());
1925 case DK_OCTA:
1926 return parseDirectiveOctaValue(IDVal);
1927 case DK_SINGLE:
1928 case DK_FLOAT:
1929 case DK_DC_S:
1930 return parseDirectiveRealValue(IDVal, APFloat::IEEEsingle());
1931 case DK_DOUBLE:
1932 case DK_DC_D:
1933 return parseDirectiveRealValue(IDVal, APFloat::IEEEdouble());
1934 case DK_ALIGN: {
1935 bool IsPow2 = !getContext().getAsmInfo()->getAlignmentIsInBytes();
1936 return parseDirectiveAlign(IsPow2, /*ExprSize=*/1);
1937 }
1938 case DK_ALIGN32: {
1939 bool IsPow2 = !getContext().getAsmInfo()->getAlignmentIsInBytes();
1940 return parseDirectiveAlign(IsPow2, /*ExprSize=*/4);
1941 }
1942 case DK_BALIGN:
1943 return parseDirectiveAlign(/*IsPow2=*/false, /*ExprSize=*/1);
1944 case DK_BALIGNW:
1945 return parseDirectiveAlign(/*IsPow2=*/false, /*ExprSize=*/2);
1946 case DK_BALIGNL:
1947 return parseDirectiveAlign(/*IsPow2=*/false, /*ExprSize=*/4);
1948 case DK_P2ALIGN:
1949 return parseDirectiveAlign(/*IsPow2=*/true, /*ExprSize=*/1);
1950 case DK_P2ALIGNW:
1951 return parseDirectiveAlign(/*IsPow2=*/true, /*ExprSize=*/2);
1952 case DK_P2ALIGNL:
1953 return parseDirectiveAlign(/*IsPow2=*/true, /*ExprSize=*/4);
1954 case DK_ORG:
1955 return parseDirectiveOrg();
1956 case DK_FILL:
1957 return parseDirectiveFill();
1958 case DK_ZERO:
1959 return parseDirectiveZero();
1960 case DK_EXTERN:
1961 eatToEndOfStatement(); // .extern is the default, ignore it.
1962 return false;
1963 case DK_GLOBL:
1964 case DK_GLOBAL:
1965 return parseDirectiveSymbolAttribute(MCSA_Global);
1966 case DK_LAZY_REFERENCE:
1967 return parseDirectiveSymbolAttribute(MCSA_LazyReference);
1968 case DK_NO_DEAD_STRIP:
1969 return parseDirectiveSymbolAttribute(MCSA_NoDeadStrip);
1970 case DK_SYMBOL_RESOLVER:
1971 return parseDirectiveSymbolAttribute(MCSA_SymbolResolver);
1972 case DK_PRIVATE_EXTERN:
1973 return parseDirectiveSymbolAttribute(MCSA_PrivateExtern);
1974 case DK_REFERENCE:
1975 return parseDirectiveSymbolAttribute(MCSA_Reference);
1976 case DK_WEAK_DEFINITION:
1977 return parseDirectiveSymbolAttribute(MCSA_WeakDefinition);
1978 case DK_WEAK_REFERENCE:
1979 return parseDirectiveSymbolAttribute(MCSA_WeakReference);
1980 case DK_WEAK_DEF_CAN_BE_HIDDEN:
1981 return parseDirectiveSymbolAttribute(MCSA_WeakDefAutoPrivate);
1982 case DK_COMM:
1983 case DK_COMMON:
1984 return parseDirectiveComm(/*IsLocal=*/false);
1985 case DK_LCOMM:
1986 return parseDirectiveComm(/*IsLocal=*/true);
1987 case DK_ABORT:
1988 return parseDirectiveAbort();
1989 case DK_INCLUDE:
1990 return parseDirectiveInclude();
1991 case DK_INCBIN:
1992 return parseDirectiveIncbin();
1993 case DK_CODE16:
1994 case DK_CODE16GCC:
1995 return TokError(Twine(IDVal) +
1996 " not currently supported for this target");
1997 case DK_REPT:
1998 return parseDirectiveRept(IDLoc, IDVal);
1999 case DK_IRP:
2000 return parseDirectiveIrp(IDLoc);
2001 case DK_IRPC:
2002 return parseDirectiveIrpc(IDLoc);
2003 case DK_ENDR:
2004 return parseDirectiveEndr(IDLoc);
2005 case DK_BUNDLE_ALIGN_MODE:
2006 return parseDirectiveBundleAlignMode();
2007 case DK_BUNDLE_LOCK:
2008 return parseDirectiveBundleLock();
2009 case DK_BUNDLE_UNLOCK:
2010 return parseDirectiveBundleUnlock();
2011 case DK_SLEB128:
2012 return parseDirectiveLEB128(true);
2013 case DK_ULEB128:
2014 return parseDirectiveLEB128(false);
2015 case DK_SPACE:
2016 case DK_SKIP:
2017 return parseDirectiveSpace(IDVal);
2018 case DK_FILE:
2019 return parseDirectiveFile(IDLoc);
2020 case DK_LINE:
2021 return parseDirectiveLine();
2022 case DK_LOC:
2023 return parseDirectiveLoc();
2024 case DK_STABS:
2025 return parseDirectiveStabs();
2026 case DK_CV_FILE:
2027 return parseDirectiveCVFile();
2028 case DK_CV_FUNC_ID:
2029 return parseDirectiveCVFuncId();
2030 case DK_CV_INLINE_SITE_ID:
2031 return parseDirectiveCVInlineSiteId();
2032 case DK_CV_LOC:
2033 return parseDirectiveCVLoc();
2034 case DK_CV_LINETABLE:
2035 return parseDirectiveCVLinetable();
2036 case DK_CV_INLINE_LINETABLE:
2037 return parseDirectiveCVInlineLinetable();
2038 case DK_CV_DEF_RANGE:
2039 return parseDirectiveCVDefRange();
2040 case DK_CV_STRING:
2041 return parseDirectiveCVString();
2042 case DK_CV_STRINGTABLE:
2043 return parseDirectiveCVStringTable();
2044 case DK_CV_FILECHECKSUMS:
2045 return parseDirectiveCVFileChecksums();
2046 case DK_CV_FILECHECKSUM_OFFSET:
2047 return parseDirectiveCVFileChecksumOffset();
2048 case DK_CV_FPO_DATA:
2049 return parseDirectiveCVFPOData();
2050 case DK_CFI_SECTIONS:
2051 return parseDirectiveCFISections();
2052 case DK_CFI_STARTPROC:
2053 return parseDirectiveCFIStartProc();
2054 case DK_CFI_ENDPROC:
2055 return parseDirectiveCFIEndProc();
2056 case DK_CFI_DEF_CFA:
2057 return parseDirectiveCFIDefCfa(IDLoc);
2058 case DK_CFI_DEF_CFA_OFFSET:
2059 return parseDirectiveCFIDefCfaOffset();
2060 case DK_CFI_ADJUST_CFA_OFFSET:
2061 return parseDirectiveCFIAdjustCfaOffset();
2062 case DK_CFI_DEF_CFA_REGISTER:
2063 return parseDirectiveCFIDefCfaRegister(IDLoc);
2064 case DK_CFI_OFFSET:
2065 return parseDirectiveCFIOffset(IDLoc);
2066 case DK_CFI_REL_OFFSET:
2067 return parseDirectiveCFIRelOffset(IDLoc);
2068 case DK_CFI_PERSONALITY:
2069 return parseDirectiveCFIPersonalityOrLsda(true);
2070 case DK_CFI_LSDA:
2071 return parseDirectiveCFIPersonalityOrLsda(false);
2072 case DK_CFI_REMEMBER_STATE:
2073 return parseDirectiveCFIRememberState();
2074 case DK_CFI_RESTORE_STATE:
2075 return parseDirectiveCFIRestoreState();
2076 case DK_CFI_SAME_VALUE:
2077 return parseDirectiveCFISameValue(IDLoc);
2078 case DK_CFI_RESTORE:
2079 return parseDirectiveCFIRestore(IDLoc);
2080 case DK_CFI_ESCAPE:
2081 return parseDirectiveCFIEscape();
2082 case DK_CFI_RETURN_COLUMN:
2083 return parseDirectiveCFIReturnColumn(IDLoc);
2084 case DK_CFI_SIGNAL_FRAME:
2085 return parseDirectiveCFISignalFrame();
2086 case DK_CFI_UNDEFINED:
2087 return parseDirectiveCFIUndefined(IDLoc);
2088 case DK_CFI_REGISTER:
2089 return parseDirectiveCFIRegister(IDLoc);
2090 case DK_CFI_WINDOW_SAVE:
2091 return parseDirectiveCFIWindowSave();
2092 case DK_MACROS_ON:
2093 case DK_MACROS_OFF:
2094 return parseDirectiveMacrosOnOff(IDVal);
2095 case DK_MACRO:
2096 return parseDirectiveMacro(IDLoc);
2097 case DK_ALTMACRO:
2098 case DK_NOALTMACRO:
2099 return parseDirectiveAltmacro(IDVal);
2100 case DK_EXITM:
2101 return parseDirectiveExitMacro(IDVal);
2102 case DK_ENDM:
2103 case DK_ENDMACRO:
2104 return parseDirectiveEndMacro(IDVal);
2105 case DK_PURGEM:
2106 return parseDirectivePurgeMacro(IDLoc);
2107 case DK_END:
2108 return parseDirectiveEnd(IDLoc);
2109 case DK_ERR:
2110 return parseDirectiveError(IDLoc, false);
2111 case DK_ERROR:
2112 return parseDirectiveError(IDLoc, true);
2113 case DK_WARNING:
2114 return parseDirectiveWarning(IDLoc);
2115 case DK_RELOC:
2116 return parseDirectiveReloc(IDLoc);
2117 case DK_DCB:
2118 case DK_DCB_W:
2119 return parseDirectiveDCB(IDVal, 2);
2120 case DK_DCB_B:
2121 return parseDirectiveDCB(IDVal, 1);
2122 case DK_DCB_D:
2123 return parseDirectiveRealDCB(IDVal, APFloat::IEEEdouble());
2124 case DK_DCB_L:
2125 return parseDirectiveDCB(IDVal, 4);
2126 case DK_DCB_S:
2127 return parseDirectiveRealDCB(IDVal, APFloat::IEEEsingle());
2128 case DK_DC_X:
2129 case DK_DCB_X:
2130 return TokError(Twine(IDVal) +
2131 " not currently supported for this target");
2132 case DK_DS:
2133 case DK_DS_W:
2134 return parseDirectiveDS(IDVal, 2);
2135 case DK_DS_B:
2136 return parseDirectiveDS(IDVal, 1);
2137 case DK_DS_D:
2138 return parseDirectiveDS(IDVal, 8);
2139 case DK_DS_L:
2140 case DK_DS_S:
2141 return parseDirectiveDS(IDVal, 4);
2142 case DK_DS_P:
2143 case DK_DS_X:
2144 return parseDirectiveDS(IDVal, 12);
2145 case DK_PRINT:
2146 return parseDirectivePrint(IDLoc);
2147 case DK_ADDRSIG:
2148 return parseDirectiveAddrsig();
2149 case DK_ADDRSIG_SYM:
2150 return parseDirectiveAddrsigSym();
2151 }
2152
2153 return Error(IDLoc, "unknown directive");
2154 }
2155
2156 // __asm _emit or __asm __emit
2157 if (ParsingInlineAsm && (IDVal == "_emit" || IDVal == "__emit" ||
2158 IDVal == "_EMIT" || IDVal == "__EMIT"))
2159 return parseDirectiveMSEmit(IDLoc, Info, IDVal.size());
2160
2161 // __asm align
2162 if (ParsingInlineAsm && (IDVal == "align" || IDVal == "ALIGN"))
2163 return parseDirectiveMSAlign(IDLoc, Info);
2164
2165 if (ParsingInlineAsm && (IDVal == "even" || IDVal == "EVEN"))
2166 Info.AsmRewrites->emplace_back(AOK_EVEN, IDLoc, 4);
2167 if (checkForValidSection())
2168 return true;
2169
2170 // Canonicalize the opcode to lower case.
2171 std::string OpcodeStr = IDVal.lower();
2172 ParseInstructionInfo IInfo(Info.AsmRewrites);
2173 bool ParseHadError = getTargetParser().ParseInstruction(IInfo, OpcodeStr, ID,
2174 Info.ParsedOperands);
2175 Info.ParseError = ParseHadError;
2176
2177 // Dump the parsed representation, if requested.
2178 if (getShowParsedOperands()) {
2179 SmallString<256> Str;
2180 raw_svector_ostream OS(Str);
2181 OS << "parsed instruction: [";
2182 for (unsigned i = 0; i != Info.ParsedOperands.size(); ++i) {
2183 if (i != 0)
2184 OS << ", ";
2185 Info.ParsedOperands[i]->print(OS);
2186 }
2187 OS << "]";
2188
2189 printMessage(IDLoc, SourceMgr::DK_Note, OS.str());
2190 }
2191
2192 // Fail even if ParseInstruction erroneously returns false.
2193 if (hasPendingError() || ParseHadError)
2194 return true;
2195
2196 // If we are generating dwarf for the current section then generate a .loc
2197 // directive for the instruction.
2198 if (!ParseHadError && enabledGenDwarfForAssembly() &&
2199 getContext().getGenDwarfSectionSyms().count(
2200 getStreamer().getCurrentSectionOnly())) {
2201 unsigned Line;
2202 if (ActiveMacros.empty())
2203 Line = SrcMgr.FindLineNumber(IDLoc, CurBuffer);
2204 else
2205 Line = SrcMgr.FindLineNumber(ActiveMacros.front()->InstantiationLoc,
2206 ActiveMacros.front()->ExitBuffer);
2207
2208 // If we previously parsed a cpp hash file line comment then make sure the
2209 // current Dwarf File is for the CppHashFilename if not then emit the
2210 // Dwarf File table for it and adjust the line number for the .loc.
2211 if (!CppHashInfo.Filename.empty()) {
2212 unsigned FileNumber = getStreamer().EmitDwarfFileDirective(
2213 0, StringRef(), CppHashInfo.Filename);
2214 getContext().setGenDwarfFileNumber(FileNumber);
2215
2216 unsigned CppHashLocLineNo =
2217 SrcMgr.FindLineNumber(CppHashInfo.Loc, CppHashInfo.Buf);
2218 Line = CppHashInfo.LineNumber - 1 + (Line - CppHashLocLineNo);
2219 }
2220
2221 getStreamer().EmitDwarfLocDirective(
2222 getContext().getGenDwarfFileNumber(), Line, 0,
2223 DWARF2_LINE_DEFAULT_IS_STMT1 ? DWARF2_FLAG_IS_STMT(1 << 0) : 0, 0, 0,
2224 StringRef());
2225 }
2226
2227 // If parsing succeeded, match the instruction.
2228 if (!ParseHadError) {
2229 uint64_t ErrorInfo;
2230 if (getTargetParser().MatchAndEmitInstruction(
2231 IDLoc, Info.Opcode, Info.ParsedOperands, Out, ErrorInfo,
2232 getTargetParser().isParsingInlineAsm()))
2233 return true;
2234 }
2235 return false;
2236}
2237
2238// Parse and erase curly braces marking block start/end
2239bool
2240AsmParser::parseCurlyBlockScope(SmallVectorImpl<AsmRewrite> &AsmStrRewrites) {
2241 // Identify curly brace marking block start/end
2242 if (Lexer.isNot(AsmToken::LCurly) && Lexer.isNot(AsmToken::RCurly))
2243 return false;
2244
2245 SMLoc StartLoc = Lexer.getLoc();
2246 Lex(); // Eat the brace
2247 if (Lexer.is(AsmToken::EndOfStatement))
2248 Lex(); // Eat EndOfStatement following the brace
2249
2250 // Erase the block start/end brace from the output asm string
2251 AsmStrRewrites.emplace_back(AOK_Skip, StartLoc, Lexer.getLoc().getPointer() -
2252 StartLoc.getPointer());
2253 return true;
2254}
2255
2256/// parseCppHashLineFilenameComment as this:
2257/// ::= # number "filename"
2258bool AsmParser::parseCppHashLineFilenameComment(SMLoc L) {
2259 Lex(); // Eat the hash token.
2260 // Lexer only ever emits HashDirective if it fully formed if it's
2261 // done the checking already so this is an internal error.
2262 assert(getTok().is(AsmToken::Integer) &&((getTok().is(AsmToken::Integer) && "Lexing Cpp line comment: Expected Integer"
) ? static_cast<void> (0) : __assert_fail ("getTok().is(AsmToken::Integer) && \"Lexing Cpp line comment: Expected Integer\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 2263, __PRETTY_FUNCTION__))
2263 "Lexing Cpp line comment: Expected Integer")((getTok().is(AsmToken::Integer) && "Lexing Cpp line comment: Expected Integer"
) ? static_cast<void> (0) : __assert_fail ("getTok().is(AsmToken::Integer) && \"Lexing Cpp line comment: Expected Integer\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 2263, __PRETTY_FUNCTION__))
;
2264 int64_t LineNumber = getTok().getIntVal();
2265 Lex();
2266 assert(getTok().is(AsmToken::String) &&((getTok().is(AsmToken::String) && "Lexing Cpp line comment: Expected String"
) ? static_cast<void> (0) : __assert_fail ("getTok().is(AsmToken::String) && \"Lexing Cpp line comment: Expected String\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 2267, __PRETTY_FUNCTION__))
2267 "Lexing Cpp line comment: Expected String")((getTok().is(AsmToken::String) && "Lexing Cpp line comment: Expected String"
) ? static_cast<void> (0) : __assert_fail ("getTok().is(AsmToken::String) && \"Lexing Cpp line comment: Expected String\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 2267, __PRETTY_FUNCTION__))
;
2268 StringRef Filename = getTok().getString();
2269 Lex();
2270
2271 // Get rid of the enclosing quotes.
2272 Filename = Filename.substr(1, Filename.size() - 2);
2273
2274 // Save the SMLoc, Filename and LineNumber for later use by diagnostics.
2275 CppHashInfo.Loc = L;
2276 CppHashInfo.Filename = Filename;
2277 CppHashInfo.LineNumber = LineNumber;
2278 CppHashInfo.Buf = CurBuffer;
2279 return false;
2280}
2281
2282/// will use the last parsed cpp hash line filename comment
2283/// for the Filename and LineNo if any in the diagnostic.
2284void AsmParser::DiagHandler(const SMDiagnostic &Diag, void *Context) {
2285 const AsmParser *Parser = static_cast<const AsmParser *>(Context);
2286 raw_ostream &OS = errs();
2287
2288 const SourceMgr &DiagSrcMgr = *Diag.getSourceMgr();
2289 SMLoc DiagLoc = Diag.getLoc();
2290 unsigned DiagBuf = DiagSrcMgr.FindBufferContainingLoc(DiagLoc);
2291 unsigned CppHashBuf =
2292 Parser->SrcMgr.FindBufferContainingLoc(Parser->CppHashInfo.Loc);
2293
2294 // Like SourceMgr::printMessage() we need to print the include stack if any
2295 // before printing the message.
2296 unsigned DiagCurBuffer = DiagSrcMgr.FindBufferContainingLoc(DiagLoc);
2297 if (!Parser->SavedDiagHandler && DiagCurBuffer &&
2298 DiagCurBuffer != DiagSrcMgr.getMainFileID()) {
2299 SMLoc ParentIncludeLoc = DiagSrcMgr.getParentIncludeLoc(DiagCurBuffer);
2300 DiagSrcMgr.PrintIncludeStack(ParentIncludeLoc, OS);
2301 }
2302
2303 // If we have not parsed a cpp hash line filename comment or the source
2304 // manager changed or buffer changed (like in a nested include) then just
2305 // print the normal diagnostic using its Filename and LineNo.
2306 if (!Parser->CppHashInfo.LineNumber || &DiagSrcMgr != &Parser->SrcMgr ||
2307 DiagBuf != CppHashBuf) {
2308 if (Parser->SavedDiagHandler)
2309 Parser->SavedDiagHandler(Diag, Parser->SavedDiagContext);
2310 else
2311 Diag.print(nullptr, OS);
2312 return;
2313 }
2314
2315 // Use the CppHashFilename and calculate a line number based on the
2316 // CppHashInfo.Loc and CppHashInfo.LineNumber relative to this Diag's SMLoc
2317 // for the diagnostic.
2318 const std::string &Filename = Parser->CppHashInfo.Filename;
2319
2320 int DiagLocLineNo = DiagSrcMgr.FindLineNumber(DiagLoc, DiagBuf);
2321 int CppHashLocLineNo =
2322 Parser->SrcMgr.FindLineNumber(Parser->CppHashInfo.Loc, CppHashBuf);
2323 int LineNo =
2324 Parser->CppHashInfo.LineNumber - 1 + (DiagLocLineNo - CppHashLocLineNo);
2325
2326 SMDiagnostic NewDiag(*Diag.getSourceMgr(), Diag.getLoc(), Filename, LineNo,
2327 Diag.getColumnNo(), Diag.getKind(), Diag.getMessage(),
2328 Diag.getLineContents(), Diag.getRanges());
2329
2330 if (Parser->SavedDiagHandler)
2331 Parser->SavedDiagHandler(NewDiag, Parser->SavedDiagContext);
2332 else
2333 NewDiag.print(nullptr, OS);
2334}
2335
2336// FIXME: This is mostly duplicated from the function in AsmLexer.cpp. The
2337// difference being that that function accepts '@' as part of identifiers and
2338// we can't do that. AsmLexer.cpp should probably be changed to handle
2339// '@' as a special case when needed.
2340static bool isIdentifierChar(char c) {
2341 return isalnum(static_cast<unsigned char>(c)) || c == '_' || c == '$' ||
2342 c == '.';
2343}
2344
2345bool AsmParser::expandMacro(raw_svector_ostream &OS, StringRef Body,
2346 ArrayRef<MCAsmMacroParameter> Parameters,
2347 ArrayRef<MCAsmMacroArgument> A,
2348 bool EnableAtPseudoVariable, SMLoc L) {
2349 unsigned NParameters = Parameters.size();
2350 bool HasVararg = NParameters ? Parameters.back().Vararg : false;
2351 if ((!IsDarwin || NParameters != 0) && NParameters != A.size())
2352 return Error(L, "Wrong number of arguments");
2353
2354 // A macro without parameters is handled differently on Darwin:
2355 // gas accepts no arguments and does no substitutions
2356 while (!Body.empty()) {
2357 // Scan for the next substitution.
2358 std::size_t End = Body.size(), Pos = 0;
2359 for (; Pos != End; ++Pos) {
2360 // Check for a substitution or escape.
2361 if (IsDarwin && !NParameters) {
2362 // This macro has no parameters, look for $0, $1, etc.
2363 if (Body[Pos] != '$' || Pos + 1 == End)
2364 continue;
2365
2366 char Next = Body[Pos + 1];
2367 if (Next == '$' || Next == 'n' ||
2368 isdigit(static_cast<unsigned char>(Next)))
2369 break;
2370 } else {
2371 // This macro has parameters, look for \foo, \bar, etc.
2372 if (Body[Pos] == '\\' && Pos + 1 != End)
2373 break;
2374 }
2375 }
2376
2377 // Add the prefix.
2378 OS << Body.slice(0, Pos);
2379
2380 // Check if we reached the end.
2381 if (Pos == End)
2382 break;
2383
2384 if (IsDarwin && !NParameters) {
2385 switch (Body[Pos + 1]) {
2386 // $$ => $
2387 case '$':
2388 OS << '$';
2389 break;
2390
2391 // $n => number of arguments
2392 case 'n':
2393 OS << A.size();
2394 break;
2395
2396 // $[0-9] => argument
2397 default: {
2398 // Missing arguments are ignored.
2399 unsigned Index = Body[Pos + 1] - '0';
2400 if (Index >= A.size())
2401 break;
2402
2403 // Otherwise substitute with the token values, with spaces eliminated.
2404 for (const AsmToken &Token : A[Index])
2405 OS << Token.getString();
2406 break;
2407 }
2408 }
2409 Pos += 2;
2410 } else {
2411 unsigned I = Pos + 1;
2412
2413 // Check for the \@ pseudo-variable.
2414 if (EnableAtPseudoVariable && Body[I] == '@' && I + 1 != End)
2415 ++I;
2416 else
2417 while (isIdentifierChar(Body[I]) && I + 1 != End)
2418 ++I;
2419
2420 const char *Begin = Body.data() + Pos + 1;
2421 StringRef Argument(Begin, I - (Pos + 1));
2422 unsigned Index = 0;
2423
2424 if (Argument == "@") {
2425 OS << NumOfMacroInstantiations;
2426 Pos += 2;
2427 } else {
2428 for (; Index < NParameters; ++Index)
2429 if (Parameters[Index].Name == Argument)
2430 break;
2431
2432 if (Index == NParameters) {
2433 if (Body[Pos + 1] == '(' && Body[Pos + 2] == ')')
2434 Pos += 3;
2435 else {
2436 OS << '\\' << Argument;
2437 Pos = I;
2438 }
2439 } else {
2440 bool VarargParameter = HasVararg && Index == (NParameters - 1);
2441 for (const AsmToken &Token : A[Index])
2442 // For altmacro mode, you can write '%expr'.
2443 // The prefix '%' evaluates the expression 'expr'
2444 // and uses the result as a string (e.g. replace %(1+2) with the
2445 // string "3").
2446 // Here, we identify the integer token which is the result of the
2447 // absolute expression evaluation and replace it with its string
2448 // representation.
2449 if (AltMacroMode && Token.getString().front() == '%' &&
2450 Token.is(AsmToken::Integer))
2451 // Emit an integer value to the buffer.
2452 OS << Token.getIntVal();
2453 // Only Token that was validated as a string and begins with '<'
2454 // is considered altMacroString!!!
2455 else if (AltMacroMode && Token.getString().front() == '<' &&
2456 Token.is(AsmToken::String)) {
2457 OS << altMacroString(Token.getStringContents());
2458 }
2459 // We expect no quotes around the string's contents when
2460 // parsing for varargs.
2461 else if (Token.isNot(AsmToken::String) || VarargParameter)
2462 OS << Token.getString();
2463 else
2464 OS << Token.getStringContents();
2465
2466 Pos += 1 + Argument.size();
2467 }
2468 }
2469 }
2470 // Update the scan point.
2471 Body = Body.substr(Pos);
2472 }
2473
2474 return false;
2475}
2476
2477MacroInstantiation::MacroInstantiation(SMLoc IL, int EB, SMLoc EL,
2478 size_t CondStackDepth)
2479 : InstantiationLoc(IL), ExitBuffer(EB), ExitLoc(EL),
2480 CondStackDepth(CondStackDepth) {}
2481
2482static bool isOperator(AsmToken::TokenKind kind) {
2483 switch (kind) {
2484 default:
2485 return false;
2486 case AsmToken::Plus:
2487 case AsmToken::Minus:
2488 case AsmToken::Tilde:
2489 case AsmToken::Slash:
2490 case AsmToken::Star:
2491 case AsmToken::Dot:
2492 case AsmToken::Equal:
2493 case AsmToken::EqualEqual:
2494 case AsmToken::Pipe:
2495 case AsmToken::PipePipe:
2496 case AsmToken::Caret:
2497 case AsmToken::Amp:
2498 case AsmToken::AmpAmp:
2499 case AsmToken::Exclaim:
2500 case AsmToken::ExclaimEqual:
2501 case AsmToken::Less:
2502 case AsmToken::LessEqual:
2503 case AsmToken::LessLess:
2504 case AsmToken::LessGreater:
2505 case AsmToken::Greater:
2506 case AsmToken::GreaterEqual:
2507 case AsmToken::GreaterGreater:
2508 return true;
2509 }
2510}
2511
2512namespace {
2513
2514class AsmLexerSkipSpaceRAII {
2515public:
2516 AsmLexerSkipSpaceRAII(AsmLexer &Lexer, bool SkipSpace) : Lexer(Lexer) {
2517 Lexer.setSkipSpace(SkipSpace);
2518 }
2519
2520 ~AsmLexerSkipSpaceRAII() {
2521 Lexer.setSkipSpace(true);
2522 }
2523
2524private:
2525 AsmLexer &Lexer;
2526};
2527
2528} // end anonymous namespace
2529
2530bool AsmParser::parseMacroArgument(MCAsmMacroArgument &MA, bool Vararg) {
2531
2532 if (Vararg) {
2533 if (Lexer.isNot(AsmToken::EndOfStatement)) {
2534 StringRef Str = parseStringToEndOfStatement();
2535 MA.emplace_back(AsmToken::String, Str);
2536 }
2537 return false;
2538 }
2539
2540 unsigned ParenLevel = 0;
2541
2542 // Darwin doesn't use spaces to delmit arguments.
2543 AsmLexerSkipSpaceRAII ScopedSkipSpace(Lexer, IsDarwin);
2544
2545 bool SpaceEaten;
2546
2547 while (true) {
2548 SpaceEaten = false;
2549 if (Lexer.is(AsmToken::Eof) || Lexer.is(AsmToken::Equal))
2550 return TokError("unexpected token in macro instantiation");
2551
2552 if (ParenLevel == 0) {
2553
2554 if (Lexer.is(AsmToken::Comma))
2555 break;
2556
2557 if (Lexer.is(AsmToken::Space)) {
2558 SpaceEaten = true;
2559 Lexer.Lex(); // Eat spaces
2560 }
2561
2562 // Spaces can delimit parameters, but could also be part an expression.
2563 // If the token after a space is an operator, add the token and the next
2564 // one into this argument
2565 if (!IsDarwin) {
2566 if (isOperator(Lexer.getKind())) {
2567 MA.push_back(getTok());
2568 Lexer.Lex();
2569
2570 // Whitespace after an operator can be ignored.
2571 if (Lexer.is(AsmToken::Space))
2572 Lexer.Lex();
2573
2574 continue;
2575 }
2576 }
2577 if (SpaceEaten)
2578 break;
2579 }
2580
2581 // handleMacroEntry relies on not advancing the lexer here
2582 // to be able to fill in the remaining default parameter values
2583 if (Lexer.is(AsmToken::EndOfStatement))
2584 break;
2585
2586 // Adjust the current parentheses level.
2587 if (Lexer.is(AsmToken::LParen))
2588 ++ParenLevel;
2589 else if (Lexer.is(AsmToken::RParen) && ParenLevel)
2590 --ParenLevel;
2591
2592 // Append the token to the current argument list.
2593 MA.push_back(getTok());
2594 Lexer.Lex();
2595 }
2596
2597 if (ParenLevel != 0)
2598 return TokError("unbalanced parentheses in macro argument");
2599 return false;
2600}
2601
2602// Parse the macro instantiation arguments.
2603bool AsmParser::parseMacroArguments(const MCAsmMacro *M,
2604 MCAsmMacroArguments &A) {
2605 const unsigned NParameters = M ? M->Parameters.size() : 0;
2606 bool NamedParametersFound = false;
2607 SmallVector<SMLoc, 4> FALocs;
2608
2609 A.resize(NParameters);
2610 FALocs.resize(NParameters);
2611
2612 // Parse two kinds of macro invocations:
2613 // - macros defined without any parameters accept an arbitrary number of them
2614 // - macros defined with parameters accept at most that many of them
2615 bool HasVararg = NParameters ? M->Parameters.back().Vararg : false;
2616 for (unsigned Parameter = 0; !NParameters || Parameter < NParameters;
2617 ++Parameter) {
2618 SMLoc IDLoc = Lexer.getLoc();
2619 MCAsmMacroParameter FA;
2620
2621 if (Lexer.is(AsmToken::Identifier) && Lexer.peekTok().is(AsmToken::Equal)) {
2622 if (parseIdentifier(FA.Name))
2623 return Error(IDLoc, "invalid argument identifier for formal argument");
2624
2625 if (Lexer.isNot(AsmToken::Equal))
2626 return TokError("expected '=' after formal parameter identifier");
2627
2628 Lex();
2629
2630 NamedParametersFound = true;
2631 }
2632 bool Vararg = HasVararg && Parameter == (NParameters - 1);
2633
2634 if (NamedParametersFound && FA.Name.empty())
2635 return Error(IDLoc, "cannot mix positional and keyword arguments");
2636
2637 SMLoc StrLoc = Lexer.getLoc();
2638 SMLoc EndLoc;
2639 if (AltMacroMode && Lexer.is(AsmToken::Percent)) {
2640 const MCExpr *AbsoluteExp;
2641 int64_t Value;
2642 /// Eat '%'
2643 Lex();
2644 if (parseExpression(AbsoluteExp, EndLoc))
2645 return false;
2646 if (!AbsoluteExp->evaluateAsAbsolute(Value,
2647 getStreamer().getAssemblerPtr()))
2648 return Error(StrLoc, "expected absolute expression");
2649 const char *StrChar = StrLoc.getPointer();
2650 const char *EndChar = EndLoc.getPointer();
2651 AsmToken newToken(AsmToken::Integer,
2652 StringRef(StrChar, EndChar - StrChar), Value);
2653 FA.Value.push_back(newToken);
2654 } else if (AltMacroMode && Lexer.is(AsmToken::Less) &&
2655 isAltmacroString(StrLoc, EndLoc)) {
2656 const char *StrChar = StrLoc.getPointer();
2657 const char *EndChar = EndLoc.getPointer();
2658 jumpToLoc(EndLoc, CurBuffer);
2659 /// Eat from '<' to '>'
2660 Lex();
2661 AsmToken newToken(AsmToken::String,
2662 StringRef(StrChar, EndChar - StrChar));
2663 FA.Value.push_back(newToken);
2664 } else if(parseMacroArgument(FA.Value, Vararg))
2665 return true;
2666
2667 unsigned PI = Parameter;
2668 if (!FA.Name.empty()) {
2669 unsigned FAI = 0;
2670 for (FAI = 0; FAI < NParameters; ++FAI)
2671 if (M->Parameters[FAI].Name == FA.Name)
2672 break;
2673
2674 if (FAI >= NParameters) {
2675 assert(M && "expected macro to be defined")((M && "expected macro to be defined") ? static_cast<
void> (0) : __assert_fail ("M && \"expected macro to be defined\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 2675, __PRETTY_FUNCTION__))
;
2676 return Error(IDLoc, "parameter named '" + FA.Name +
2677 "' does not exist for macro '" + M->Name + "'");
2678 }
2679 PI = FAI;
2680 }
2681
2682 if (!FA.Value.empty()) {
2683 if (A.size() <= PI)
2684 A.resize(PI + 1);
2685 A[PI] = FA.Value;
2686
2687 if (FALocs.size() <= PI)
2688 FALocs.resize(PI + 1);
2689
2690 FALocs[PI] = Lexer.getLoc();
2691 }
2692
2693 // At the end of the statement, fill in remaining arguments that have
2694 // default values. If there aren't any, then the next argument is
2695 // required but missing
2696 if (Lexer.is(AsmToken::EndOfStatement)) {
2697 bool Failure = false;
2698 for (unsigned FAI = 0; FAI < NParameters; ++FAI) {
2699 if (A[FAI].empty()) {
2700 if (M->Parameters[FAI].Required) {
2701 Error(FALocs[FAI].isValid() ? FALocs[FAI] : Lexer.getLoc(),
2702 "missing value for required parameter "
2703 "'" + M->Parameters[FAI].Name + "' in macro '" + M->Name + "'");
2704 Failure = true;
2705 }
2706
2707 if (!M->Parameters[FAI].Value.empty())
2708 A[FAI] = M->Parameters[FAI].Value;
2709 }
2710 }
2711 return Failure;
2712 }
2713
2714 if (Lexer.is(AsmToken::Comma))
2715 Lex();
2716 }
2717
2718 return TokError("too many positional arguments");
2719}
2720
2721bool AsmParser::handleMacroEntry(const MCAsmMacro *M, SMLoc NameLoc) {
2722 // Arbitrarily limit macro nesting depth (default matches 'as'). We can
2723 // eliminate this, although we should protect against infinite loops.
2724 unsigned MaxNestingDepth = AsmMacroMaxNestingDepth;
2725 if (ActiveMacros.size() == MaxNestingDepth) {
2726 std::ostringstream MaxNestingDepthError;
2727 MaxNestingDepthError << "macros cannot be nested more than "
2728 << MaxNestingDepth << " levels deep."
2729 << " Use -asm-macro-max-nesting-depth to increase "
2730 "this limit.";
2731 return TokError(MaxNestingDepthError.str());
2732 }
2733
2734 MCAsmMacroArguments A;
2735 if (parseMacroArguments(M, A))
2736 return true;
2737
2738 // Macro instantiation is lexical, unfortunately. We construct a new buffer
2739 // to hold the macro body with substitutions.
2740 SmallString<256> Buf;
2741 StringRef Body = M->Body;
2742 raw_svector_ostream OS(Buf);
2743
2744 if (expandMacro(OS, Body, M->Parameters, A, true, getTok().getLoc()))
2745 return true;
2746
2747 // We include the .endmacro in the buffer as our cue to exit the macro
2748 // instantiation.
2749 OS << ".endmacro\n";
2750
2751 std::unique_ptr<MemoryBuffer> Instantiation =
2752 MemoryBuffer::getMemBufferCopy(OS.str(), "<instantiation>");
2753
2754 // Create the macro instantiation object and add to the current macro
2755 // instantiation stack.
2756 MacroInstantiation *MI = new MacroInstantiation(
2757 NameLoc, CurBuffer, getTok().getLoc(), TheCondStack.size());
2758 ActiveMacros.push_back(MI);
2759
2760 ++NumOfMacroInstantiations;
2761
2762 // Jump to the macro instantiation and prime the lexer.
2763 CurBuffer = SrcMgr.AddNewSourceBuffer(std::move(Instantiation), SMLoc());
2764 Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer());
2765 Lex();
2766
2767 return false;
2768}
2769
2770void AsmParser::handleMacroExit() {
2771 // Jump to the EndOfStatement we should return to, and consume it.
2772 jumpToLoc(ActiveMacros.back()->ExitLoc, ActiveMacros.back()->ExitBuffer);
2773 Lex();
2774
2775 // Pop the instantiation entry.
2776 delete ActiveMacros.back();
2777 ActiveMacros.pop_back();
2778}
2779
2780bool AsmParser::parseAssignment(StringRef Name, bool allow_redef,
2781 bool NoDeadStrip) {
2782 MCSymbol *Sym;
2783 const MCExpr *Value;
2784 if (MCParserUtils::parseAssignmentExpression(Name, allow_redef, *this, Sym,
2785 Value))
2786 return true;
2787
2788 if (!Sym) {
2789 // In the case where we parse an expression starting with a '.', we will
2790 // not generate an error, nor will we create a symbol. In this case we
2791 // should just return out.
2792 return false;
2793 }
2794
2795 // Do the assignment.
2796 Out.EmitAssignment(Sym, Value);
2797 if (NoDeadStrip)
2798 Out.EmitSymbolAttribute(Sym, MCSA_NoDeadStrip);
2799
2800 return false;
2801}
2802
2803/// parseIdentifier:
2804/// ::= identifier
2805/// ::= string
2806bool AsmParser::parseIdentifier(StringRef &Res) {
2807 // The assembler has relaxed rules for accepting identifiers, in particular we
2808 // allow things like '.globl $foo' and '.def @feat.00', which would normally be
2809 // separate tokens. At this level, we have already lexed so we cannot (currently)
2810 // handle this as a context dependent token, instead we detect adjacent tokens
2811 // and return the combined identifier.
2812 if (Lexer.is(AsmToken::Dollar) || Lexer.is(AsmToken::At)) {
2813 SMLoc PrefixLoc = getLexer().getLoc();
2814
2815 // Consume the prefix character, and check for a following identifier.
2816
2817 AsmToken Buf[1];
2818 Lexer.peekTokens(Buf, false);
2819
2820 if (Buf[0].isNot(AsmToken::Identifier))
2821 return true;
2822
2823 // We have a '$' or '@' followed by an identifier, make sure they are adjacent.
2824 if (PrefixLoc.getPointer() + 1 != Buf[0].getLoc().getPointer())
2825 return true;
2826
2827 // eat $ or @
2828 Lexer.Lex(); // Lexer's Lex guarantees consecutive token.
2829 // Construct the joined identifier and consume the token.
2830 Res =
2831 StringRef(PrefixLoc.getPointer(), getTok().getIdentifier().size() + 1);
2832 Lex(); // Parser Lex to maintain invariants.
2833 return false;
2834 }
2835
2836 if (Lexer.isNot(AsmToken::Identifier) && Lexer.isNot(AsmToken::String))
2837 return true;
2838
2839 Res = getTok().getIdentifier();
2840
2841 Lex(); // Consume the identifier token.
2842
2843 return false;
2844}
2845
2846/// parseDirectiveSet:
2847/// ::= .equ identifier ',' expression
2848/// ::= .equiv identifier ',' expression
2849/// ::= .set identifier ',' expression
2850bool AsmParser::parseDirectiveSet(StringRef IDVal, bool allow_redef) {
2851 StringRef Name;
2852 if (check(parseIdentifier(Name), "expected identifier") ||
2853 parseToken(AsmToken::Comma) || parseAssignment(Name, allow_redef, true))
2854 return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
2855 return false;
2856}
2857
2858bool AsmParser::parseEscapedString(std::string &Data) {
2859 if (check(getTok().isNot(AsmToken::String), "expected string"))
2860 return true;
2861
2862 Data = "";
2863 StringRef Str = getTok().getStringContents();
2864 for (unsigned i = 0, e = Str.size(); i != e; ++i) {
2865 if (Str[i] != '\\') {
2866 Data += Str[i];
2867 continue;
2868 }
2869
2870 // Recognize escaped characters. Note that this escape semantics currently
2871 // loosely follows Darwin 'as'. Notably, it doesn't support hex escapes.
2872 ++i;
2873 if (i == e)
2874 return TokError("unexpected backslash at end of string");
2875
2876 // Recognize octal sequences.
2877 if ((unsigned)(Str[i] - '0') <= 7) {
2878 // Consume up to three octal characters.
2879 unsigned Value = Str[i] - '0';
2880
2881 if (i + 1 != e && ((unsigned)(Str[i + 1] - '0')) <= 7) {
2882 ++i;
2883 Value = Value * 8 + (Str[i] - '0');
2884
2885 if (i + 1 != e && ((unsigned)(Str[i + 1] - '0')) <= 7) {
2886 ++i;
2887 Value = Value * 8 + (Str[i] - '0');
2888 }
2889 }
2890
2891 if (Value > 255)
2892 return TokError("invalid octal escape sequence (out of range)");
2893
2894 Data += (unsigned char)Value;
2895 continue;
2896 }
2897
2898 // Otherwise recognize individual escapes.
2899 switch (Str[i]) {
2900 default:
2901 // Just reject invalid escape sequences for now.
2902 return TokError("invalid escape sequence (unrecognized character)");
2903
2904 case 'b': Data += '\b'; break;
2905 case 'f': Data += '\f'; break;
2906 case 'n': Data += '\n'; break;
2907 case 'r': Data += '\r'; break;
2908 case 't': Data += '\t'; break;
2909 case '"': Data += '"'; break;
2910 case '\\': Data += '\\'; break;
2911 }
2912 }
2913
2914 Lex();
2915 return false;
2916}
2917
2918/// parseDirectiveAscii:
2919/// ::= ( .ascii | .asciz | .string ) [ "string" ( , "string" )* ]
2920bool AsmParser::parseDirectiveAscii(StringRef IDVal, bool ZeroTerminated) {
2921 auto parseOp = [&]() -> bool {
2922 std::string Data;
2923 if (checkForValidSection() || parseEscapedString(Data))
2924 return true;
2925 getStreamer().EmitBytes(Data);
2926 if (ZeroTerminated)
2927 getStreamer().EmitBytes(StringRef("\0", 1));
2928 return false;
2929 };
2930
2931 if (parseMany(parseOp))
2932 return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
2933 return false;
2934}
2935
2936/// parseDirectiveReloc
2937/// ::= .reloc expression , identifier [ , expression ]
2938bool AsmParser::parseDirectiveReloc(SMLoc DirectiveLoc) {
2939 const MCExpr *Offset;
2940 const MCExpr *Expr = nullptr;
2941 int64_t OffsetValue;
2942 SMLoc OffsetLoc = Lexer.getTok().getLoc();
2943
2944 if (parseExpression(Offset))
2945 return true;
2946
2947 if ((Offset->evaluateAsAbsolute(OffsetValue,
2948 getStreamer().getAssemblerPtr()) &&
2949 check(OffsetValue < 0, OffsetLoc, "expression is negative")) ||
2950 (check(Offset->getKind() != llvm::MCExpr::Constant &&
2951 Offset->getKind() != llvm::MCExpr::SymbolRef,
2952 OffsetLoc, "expected non-negative number or a label")) ||
2953 (parseToken(AsmToken::Comma, "expected comma") ||
2954 check(getTok().isNot(AsmToken::Identifier), "expected relocation name")))
2955 return true;
2956
2957 SMLoc NameLoc = Lexer.getTok().getLoc();
2958 StringRef Name = Lexer.getTok().getIdentifier();
2959 Lex();
2960
2961 if (Lexer.is(AsmToken::Comma)) {
2962 Lex();
2963 SMLoc ExprLoc = Lexer.getLoc();
2964 if (parseExpression(Expr))
2965 return true;
2966
2967 MCValue Value;
2968 if (!Expr->evaluateAsRelocatable(Value, nullptr, nullptr))
2969 return Error(ExprLoc, "expression must be relocatable");
2970 }
2971
2972 if (parseToken(AsmToken::EndOfStatement,
2973 "unexpected token in .reloc directive"))
2974 return true;
2975
2976 const MCTargetAsmParser &MCT = getTargetParser();
2977 const MCSubtargetInfo &STI = MCT.getSTI();
2978 if (getStreamer().EmitRelocDirective(*Offset, Name, Expr, DirectiveLoc, STI))
2979 return Error(NameLoc, "unknown relocation name");
2980
2981 return false;
2982}
2983
2984/// parseDirectiveValue
2985/// ::= (.byte | .short | ... ) [ expression (, expression)* ]
2986bool AsmParser::parseDirectiveValue(StringRef IDVal, unsigned Size) {
2987 auto parseOp = [&]() -> bool {
2988 const MCExpr *Value;
2989 SMLoc ExprLoc = getLexer().getLoc();
2990 if (checkForValidSection() || parseExpression(Value))
2991 return true;
2992 // Special case constant expressions to match code generator.
2993 if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value)) {
2994 assert(Size <= 8 && "Invalid size")((Size <= 8 && "Invalid size") ? static_cast<void
> (0) : __assert_fail ("Size <= 8 && \"Invalid size\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 2994, __PRETTY_FUNCTION__))
;
2995 uint64_t IntValue = MCE->getValue();
2996 if (!isUIntN(8 * Size, IntValue) && !isIntN(8 * Size, IntValue))
2997 return Error(ExprLoc, "out of range literal value");
2998 getStreamer().EmitIntValue(IntValue, Size);
2999 } else
3000 getStreamer().EmitValue(Value, Size, ExprLoc);
3001 return false;
3002 };
3003
3004 if (parseMany(parseOp))
3005 return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
3006 return false;
3007}
3008
3009static bool parseHexOcta(AsmParser &Asm, uint64_t &hi, uint64_t &lo) {
3010 if (Asm.getTok().isNot(AsmToken::Integer) &&
3011 Asm.getTok().isNot(AsmToken::BigNum))
3012 return Asm.TokError("unknown token in expression");
3013 SMLoc ExprLoc = Asm.getTok().getLoc();
3014 APInt IntValue = Asm.getTok().getAPIntVal();
3015 Asm.Lex();
3016 if (!IntValue.isIntN(128))
3017 return Asm.Error(ExprLoc, "out of range literal value");
3018 if (!IntValue.isIntN(64)) {
3019 hi = IntValue.getHiBits(IntValue.getBitWidth() - 64).getZExtValue();
3020 lo = IntValue.getLoBits(64).getZExtValue();
3021 } else {
3022 hi = 0;
3023 lo = IntValue.getZExtValue();
3024 }
3025 return false;
3026}
3027
3028/// ParseDirectiveOctaValue
3029/// ::= .octa [ hexconstant (, hexconstant)* ]
3030
3031bool AsmParser::parseDirectiveOctaValue(StringRef IDVal) {
3032 auto parseOp = [&]() -> bool {
3033 if (checkForValidSection())
3034 return true;
3035 uint64_t hi, lo;
3036 if (parseHexOcta(*this, hi, lo))
3037 return true;
3038 if (MAI.isLittleEndian()) {
3039 getStreamer().EmitIntValue(lo, 8);
3040 getStreamer().EmitIntValue(hi, 8);
3041 } else {
3042 getStreamer().EmitIntValue(hi, 8);
3043 getStreamer().EmitIntValue(lo, 8);
3044 }
3045 return false;
3046 };
3047
3048 if (parseMany(parseOp))
3049 return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
3050 return false;
3051}
3052
3053bool AsmParser::parseRealValue(const fltSemantics &Semantics, APInt &Res) {
3054 // We don't truly support arithmetic on floating point expressions, so we
3055 // have to manually parse unary prefixes.
3056 bool IsNeg = false;
3057 if (getLexer().is(AsmToken::Minus)) {
3058 Lexer.Lex();
3059 IsNeg = true;
3060 } else if (getLexer().is(AsmToken::Plus))
3061 Lexer.Lex();
3062
3063 if (Lexer.is(AsmToken::Error))
3064 return TokError(Lexer.getErr());
3065 if (Lexer.isNot(AsmToken::Integer) && Lexer.isNot(AsmToken::Real) &&
3066 Lexer.isNot(AsmToken::Identifier))
3067 return TokError("unexpected token in directive");
3068
3069 // Convert to an APFloat.
3070 APFloat Value(Semantics);
3071 StringRef IDVal = getTok().getString();
3072 if (getLexer().is(AsmToken::Identifier)) {
3073 if (!IDVal.compare_lower("infinity") || !IDVal.compare_lower("inf"))
3074 Value = APFloat::getInf(Semantics);
3075 else if (!IDVal.compare_lower("nan"))
3076 Value = APFloat::getNaN(Semantics, false, ~0);
3077 else
3078 return TokError("invalid floating point literal");
3079 } else if (Value.convertFromString(IDVal, APFloat::rmNearestTiesToEven) ==
3080 APFloat::opInvalidOp)
3081 return TokError("invalid floating point literal");
3082 if (IsNeg)
3083 Value.changeSign();
3084
3085 // Consume the numeric token.
3086 Lex();
3087
3088 Res = Value.bitcastToAPInt();
3089
3090 return false;
3091}
3092
3093/// parseDirectiveRealValue
3094/// ::= (.single | .double) [ expression (, expression)* ]
3095bool AsmParser::parseDirectiveRealValue(StringRef IDVal,
3096 const fltSemantics &Semantics) {
3097 auto parseOp = [&]() -> bool {
3098 APInt AsInt;
3099 if (checkForValidSection() || parseRealValue(Semantics, AsInt))
3100 return true;
3101 getStreamer().EmitIntValue(AsInt.getLimitedValue(),
3102 AsInt.getBitWidth() / 8);
3103 return false;
3104 };
3105
3106 if (parseMany(parseOp))
3107 return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
3108 return false;
3109}
3110
3111/// parseDirectiveZero
3112/// ::= .zero expression
3113bool AsmParser::parseDirectiveZero() {
3114 SMLoc NumBytesLoc = Lexer.getLoc();
3115 const MCExpr *NumBytes;
3116 if (checkForValidSection() || parseExpression(NumBytes))
3117 return true;
3118
3119 int64_t Val = 0;
3120 if (getLexer().is(AsmToken::Comma)) {
3121 Lex();
3122 if (parseAbsoluteExpression(Val))
3123 return true;
3124 }
3125
3126 if (parseToken(AsmToken::EndOfStatement,
3127 "unexpected token in '.zero' directive"))
3128 return true;
3129 getStreamer().emitFill(*NumBytes, Val, NumBytesLoc);
3130
3131 return false;
3132}
3133
3134/// parseDirectiveFill
3135/// ::= .fill expression [ , expression [ , expression ] ]
3136bool AsmParser::parseDirectiveFill() {
3137 SMLoc NumValuesLoc = Lexer.getLoc();
3138 const MCExpr *NumValues;
3139 if (checkForValidSection() || parseExpression(NumValues))
3140 return true;
3141
3142 int64_t FillSize = 1;
3143 int64_t FillExpr = 0;
3144
3145 SMLoc SizeLoc, ExprLoc;
3146
3147 if (parseOptionalToken(AsmToken::Comma)) {
3148 SizeLoc = getTok().getLoc();
3149 if (parseAbsoluteExpression(FillSize))
3150 return true;
3151 if (parseOptionalToken(AsmToken::Comma)) {
3152 ExprLoc = getTok().getLoc();
3153 if (parseAbsoluteExpression(FillExpr))
3154 return true;
3155 }
3156 }
3157 if (parseToken(AsmToken::EndOfStatement,
3158 "unexpected token in '.fill' directive"))
3159 return true;
3160
3161 if (FillSize < 0) {
3162 Warning(SizeLoc, "'.fill' directive with negative size has no effect");
3163 return false;
3164 }
3165 if (FillSize > 8) {
3166 Warning(SizeLoc, "'.fill' directive with size greater than 8 has been truncated to 8");
3167 FillSize = 8;
3168 }
3169
3170 if (!isUInt<32>(FillExpr) && FillSize > 4)
3171 Warning(ExprLoc, "'.fill' directive pattern has been truncated to 32-bits");
3172
3173 getStreamer().emitFill(*NumValues, FillSize, FillExpr, NumValuesLoc);
3174
3175 return false;
3176}
3177
3178/// parseDirectiveOrg
3179/// ::= .org expression [ , expression ]
3180bool AsmParser::parseDirectiveOrg() {
3181 const MCExpr *Offset;
3182 SMLoc OffsetLoc = Lexer.getLoc();
3183 if (checkForValidSection() || parseExpression(Offset))
3184 return true;
3185
3186 // Parse optional fill expression.
3187 int64_t FillExpr = 0;
3188 if (parseOptionalToken(AsmToken::Comma))
3189 if (parseAbsoluteExpression(FillExpr))
3190 return addErrorSuffix(" in '.org' directive");
3191 if (parseToken(AsmToken::EndOfStatement))
3192 return addErrorSuffix(" in '.org' directive");
3193
3194 getStreamer().emitValueToOffset(Offset, FillExpr, OffsetLoc);
3195 return false;
3196}
3197
3198/// parseDirectiveAlign
3199/// ::= {.align, ...} expression [ , expression [ , expression ]]
3200bool AsmParser::parseDirectiveAlign(bool IsPow2, unsigned ValueSize) {
3201 SMLoc AlignmentLoc = getLexer().getLoc();
3202 int64_t Alignment;
3203 SMLoc MaxBytesLoc;
3204 bool HasFillExpr = false;
3205 int64_t FillExpr = 0;
3206 int64_t MaxBytesToFill = 0;
3207
3208 auto parseAlign = [&]() -> bool {
3209 if (parseAbsoluteExpression(Alignment))
3210 return true;
3211 if (parseOptionalToken(AsmToken::Comma)) {
3212 // The fill expression can be omitted while specifying a maximum number of
3213 // alignment bytes, e.g:
3214 // .align 3,,4
3215 if (getTok().isNot(AsmToken::Comma)) {
3216 HasFillExpr = true;
3217 if (parseAbsoluteExpression(FillExpr))
3218 return true;
3219 }
3220 if (parseOptionalToken(AsmToken::Comma))
3221 if (parseTokenLoc(MaxBytesLoc) ||
3222 parseAbsoluteExpression(MaxBytesToFill))
3223 return true;
3224 }
3225 return parseToken(AsmToken::EndOfStatement);
3226 };
3227
3228 if (checkForValidSection())
3229 return addErrorSuffix(" in directive");
3230 // Ignore empty '.p2align' directives for GNU-as compatibility
3231 if (IsPow2 && (ValueSize == 1) && getTok().is(AsmToken::EndOfStatement)) {
3232 Warning(AlignmentLoc, "p2align directive with no operand(s) is ignored");
3233 return parseToken(AsmToken::EndOfStatement);
3234 }
3235 if (parseAlign())
3236 return addErrorSuffix(" in directive");
3237
3238 // Always emit an alignment here even if we thrown an error.
3239 bool ReturnVal = false;
3240
3241 // Compute alignment in bytes.
3242 if (IsPow2) {
3243 // FIXME: Diagnose overflow.
3244 if (Alignment >= 32) {
3245 ReturnVal |= Error(AlignmentLoc, "invalid alignment value");
3246 Alignment = 31;
3247 }
3248
3249 Alignment = 1ULL << Alignment;
3250 } else {
3251 // Reject alignments that aren't either a power of two or zero,
3252 // for gas compatibility. Alignment of zero is silently rounded
3253 // up to one.
3254 if (Alignment == 0)
3255 Alignment = 1;
3256 if (!isPowerOf2_64(Alignment))
3257 ReturnVal |= Error(AlignmentLoc, "alignment must be a power of 2");
3258 }
3259
3260 // Diagnose non-sensical max bytes to align.
3261 if (MaxBytesLoc.isValid()) {
3262 if (MaxBytesToFill < 1) {
3263 ReturnVal |= Error(MaxBytesLoc,
3264 "alignment directive can never be satisfied in this "
3265 "many bytes, ignoring maximum bytes expression");
3266 MaxBytesToFill = 0;
3267 }
3268
3269 if (MaxBytesToFill >= Alignment) {
3270 Warning(MaxBytesLoc, "maximum bytes expression exceeds alignment and "
3271 "has no effect");
3272 MaxBytesToFill = 0;
3273 }
3274 }
3275
3276 // Check whether we should use optimal code alignment for this .align
3277 // directive.
3278 const MCSection *Section = getStreamer().getCurrentSectionOnly();
3279 assert(Section && "must have section to emit alignment")((Section && "must have section to emit alignment") ?
static_cast<void> (0) : __assert_fail ("Section && \"must have section to emit alignment\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 3279, __PRETTY_FUNCTION__))
;
3280 bool UseCodeAlign = Section->UseCodeAlign();
3281 if ((!HasFillExpr || Lexer.getMAI().getTextAlignFillValue() == FillExpr) &&
3282 ValueSize == 1 && UseCodeAlign) {
3283 getStreamer().EmitCodeAlignment(Alignment, MaxBytesToFill);
3284 } else {
3285 // FIXME: Target specific behavior about how the "extra" bytes are filled.
3286 getStreamer().EmitValueToAlignment(Alignment, FillExpr, ValueSize,
3287 MaxBytesToFill);
3288 }
3289
3290 return ReturnVal;
3291}
3292
3293/// parseDirectiveFile
3294/// ::= .file filename
3295/// ::= .file number [directory] filename [md5 checksum] [source source-text]
3296bool AsmParser::parseDirectiveFile(SMLoc DirectiveLoc) {
3297 // FIXME: I'm not sure what this is.
3298 int64_t FileNumber = -1;
3299 if (getLexer().is(AsmToken::Integer)) {
3300 FileNumber = getTok().getIntVal();
3301 Lex();
3302
3303 if (FileNumber < 0)
3304 return TokError("negative file number");
3305 }
3306
3307 std::string Path;
3308
3309 // Usually the directory and filename together, otherwise just the directory.
3310 // Allow the strings to have escaped octal character sequence.
3311 if (check(getTok().isNot(AsmToken::String),
3312 "unexpected token in '.file' directive") ||
3313 parseEscapedString(Path))
3314 return true;
3315
3316 StringRef Directory;
3317 StringRef Filename;
3318 std::string FilenameData;
3319 if (getLexer().is(AsmToken::String)) {
3320 if (check(FileNumber == -1,
3321 "explicit path specified, but no file number") ||
3322 parseEscapedString(FilenameData))
3323 return true;
3324 Filename = FilenameData;
3325 Directory = Path;
3326 } else {
3327 Filename = Path;
3328 }
3329
3330 uint64_t MD5Hi, MD5Lo;
3331 bool HasMD5 = false;
3332
3333 Optional<StringRef> Source;
3334 bool HasSource = false;
3335 std::string SourceString;
3336
3337 while (!parseOptionalToken(AsmToken::EndOfStatement)) {
3338 StringRef Keyword;
3339 if (check(getTok().isNot(AsmToken::Identifier),
3340 "unexpected token in '.file' directive") ||
3341 parseIdentifier(Keyword))
3342 return true;
3343 if (Keyword == "md5") {
3344 HasMD5 = true;
3345 if (check(FileNumber == -1,
3346 "MD5 checksum specified, but no file number") ||
3347 parseHexOcta(*this, MD5Hi, MD5Lo))
3348 return true;
3349 } else if (Keyword == "source") {
3350 HasSource = true;
3351 if (check(FileNumber == -1,
3352 "source specified, but no file number") ||
3353 check(getTok().isNot(AsmToken::String),
3354 "unexpected token in '.file' directive") ||
3355 parseEscapedString(SourceString))
3356 return true;
3357 } else {
3358 return TokError("unexpected token in '.file' directive");
3359 }
3360 }
3361
3362 if (FileNumber == -1)
3363 getStreamer().EmitFileDirective(Filename);
3364 else {
3365 // In case there is a -g option as well as debug info from directive .file,
3366 // we turn off the -g option, directly use the existing debug info instead.
3367 // Also reset any implicit ".file 0" for the assembler source.
3368 if (Ctx.getGenDwarfForAssembly()) {
3369 Ctx.getMCDwarfLineTable(0).resetRootFile();
3370 Ctx.setGenDwarfForAssembly(false);
3371 }
3372
3373 MD5::MD5Result *CKMem = nullptr;
3374 if (HasMD5) {
3375 CKMem = (MD5::MD5Result *)Ctx.allocate(sizeof(MD5::MD5Result), 1);
3376 for (unsigned i = 0; i != 8; ++i) {
3377 CKMem->Bytes[i] = uint8_t(MD5Hi >> ((7 - i) * 8));
3378 CKMem->Bytes[i + 8] = uint8_t(MD5Lo >> ((7 - i) * 8));
3379 }
3380 }
3381 if (HasSource) {
3382 char *SourceBuf = static_cast<char *>(Ctx.allocate(SourceString.size()));
3383 memcpy(SourceBuf, SourceString.data(), SourceString.size());
3384 Source = StringRef(SourceBuf, SourceString.size());
3385 }
3386 if (FileNumber == 0) {
3387 if (Ctx.getDwarfVersion() < 5)
3388 return Warning(DirectiveLoc, "file 0 not supported prior to DWARF-5");
3389 getStreamer().emitDwarfFile0Directive(Directory, Filename, CKMem, Source);
3390 } else {
3391 Expected<unsigned> FileNumOrErr = getStreamer().tryEmitDwarfFileDirective(
3392 FileNumber, Directory, Filename, CKMem, Source);
3393 if (!FileNumOrErr)
3394 return Error(DirectiveLoc, toString(FileNumOrErr.takeError()));
3395 FileNumber = FileNumOrErr.get();
Value stored to 'FileNumber' is never read
3396 }
3397 // Alert the user if there are some .file directives with MD5 and some not.
3398 // But only do that once.
3399 if (!ReportedInconsistentMD5 && !Ctx.isDwarfMD5UsageConsistent(0)) {
3400 ReportedInconsistentMD5 = true;
3401 return Warning(DirectiveLoc, "inconsistent use of MD5 checksums");
3402 }
3403 }
3404
3405 return false;
3406}
3407
3408/// parseDirectiveLine
3409/// ::= .line [number]
3410bool AsmParser::parseDirectiveLine() {
3411 int64_t LineNumber;
3412 if (getLexer().is(AsmToken::Integer)) {
3413 if (parseIntToken(LineNumber, "unexpected token in '.line' directive"))
3414 return true;
3415 (void)LineNumber;
3416 // FIXME: Do something with the .line.
3417 }
3418 if (parseToken(AsmToken::EndOfStatement,
3419 "unexpected token in '.line' directive"))
3420 return true;
3421
3422 return false;
3423}
3424
3425/// parseDirectiveLoc
3426/// ::= .loc FileNumber [LineNumber] [ColumnPos] [basic_block] [prologue_end]
3427/// [epilogue_begin] [is_stmt VALUE] [isa VALUE]
3428/// The first number is a file number, must have been previously assigned with
3429/// a .file directive, the second number is the line number and optionally the
3430/// third number is a column position (zero if not specified). The remaining
3431/// optional items are .loc sub-directives.
3432bool AsmParser::parseDirectiveLoc() {
3433 int64_t FileNumber = 0, LineNumber = 0;
3434 SMLoc Loc = getTok().getLoc();
3435 if (parseIntToken(FileNumber, "unexpected token in '.loc' directive") ||
3436 check(FileNumber < 1 && Ctx.getDwarfVersion() < 5, Loc,
3437 "file number less than one in '.loc' directive") ||
3438 check(!getContext().isValidDwarfFileNumber(FileNumber), Loc,
3439 "unassigned file number in '.loc' directive"))
3440 return true;
3441
3442 // optional
3443 if (getLexer().is(AsmToken::Integer)) {
3444 LineNumber = getTok().getIntVal();
3445 if (LineNumber < 0)
3446 return TokError("line number less than zero in '.loc' directive");
3447 Lex();
3448 }
3449
3450 int64_t ColumnPos = 0;
3451 if (getLexer().is(AsmToken::Integer)) {
3452 ColumnPos = getTok().getIntVal();
3453 if (ColumnPos < 0)
3454 return TokError("column position less than zero in '.loc' directive");
3455 Lex();
3456 }
3457
3458 unsigned Flags = DWARF2_LINE_DEFAULT_IS_STMT1 ? DWARF2_FLAG_IS_STMT(1 << 0) : 0;
3459 unsigned Isa = 0;
3460 int64_t Discriminator = 0;
3461
3462 auto parseLocOp = [&]() -> bool {
3463 StringRef Name;
3464 SMLoc Loc = getTok().getLoc();
3465 if (parseIdentifier(Name))
3466 return TokError("unexpected token in '.loc' directive");
3467
3468 if (Name == "basic_block")
3469 Flags |= DWARF2_FLAG_BASIC_BLOCK(1 << 1);
3470 else if (Name == "prologue_end")
3471 Flags |= DWARF2_FLAG_PROLOGUE_END(1 << 2);
3472 else if (Name == "epilogue_begin")
3473 Flags |= DWARF2_FLAG_EPILOGUE_BEGIN(1 << 3);
3474 else if (Name == "is_stmt") {
3475 Loc = getTok().getLoc();
3476 const MCExpr *Value;
3477 if (parseExpression(Value))
3478 return true;
3479 // The expression must be the constant 0 or 1.
3480 if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value)) {
3481 int Value = MCE->getValue();
3482 if (Value == 0)
3483 Flags &= ~DWARF2_FLAG_IS_STMT(1 << 0);
3484 else if (Value == 1)
3485 Flags |= DWARF2_FLAG_IS_STMT(1 << 0);
3486 else
3487 return Error(Loc, "is_stmt value not 0 or 1");
3488 } else {
3489 return Error(Loc, "is_stmt value not the constant value of 0 or 1");
3490 }
3491 } else if (Name == "isa") {
3492 Loc = getTok().getLoc();
3493 const MCExpr *Value;
3494 if (parseExpression(Value))
3495 return true;
3496 // The expression must be a constant greater or equal to 0.
3497 if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value)) {
3498 int Value = MCE->getValue();
3499 if (Value < 0)
3500 return Error(Loc, "isa number less than zero");
3501 Isa = Value;
3502 } else {
3503 return Error(Loc, "isa number not a constant value");
3504 }
3505 } else if (Name == "discriminator") {
3506 if (parseAbsoluteExpression(Discriminator))
3507 return true;
3508 } else {
3509 return Error(Loc, "unknown sub-directive in '.loc' directive");
3510 }
3511 return false;
3512 };
3513
3514 if (parseMany(parseLocOp, false /*hasComma*/))
3515 return true;
3516
3517 getStreamer().EmitDwarfLocDirective(FileNumber, LineNumber, ColumnPos, Flags,
3518 Isa, Discriminator, StringRef());
3519
3520 return false;
3521}
3522
3523/// parseDirectiveStabs
3524/// ::= .stabs string, number, number, number
3525bool AsmParser::parseDirectiveStabs() {
3526 return TokError("unsupported directive '.stabs'");
3527}
3528
3529/// parseDirectiveCVFile
3530/// ::= .cv_file number filename [checksum] [checksumkind]
3531bool AsmParser::parseDirectiveCVFile() {
3532 SMLoc FileNumberLoc = getTok().getLoc();
3533 int64_t FileNumber;
3534 std::string Filename;
3535 std::string Checksum;
3536 int64_t ChecksumKind = 0;
3537
3538 if (parseIntToken(FileNumber,
3539 "expected file number in '.cv_file' directive") ||
3540 check(FileNumber < 1, FileNumberLoc, "file number less than one") ||
3541 check(getTok().isNot(AsmToken::String),
3542 "unexpected token in '.cv_file' directive") ||
3543 parseEscapedString(Filename))
3544 return true;
3545 if (!parseOptionalToken(AsmToken::EndOfStatement)) {
3546 if (check(getTok().isNot(AsmToken::String),
3547 "unexpected token in '.cv_file' directive") ||
3548 parseEscapedString(Checksum) ||
3549 parseIntToken(ChecksumKind,
3550 "expected checksum kind in '.cv_file' directive") ||
3551 parseToken(AsmToken::EndOfStatement,
3552 "unexpected token in '.cv_file' directive"))
3553 return true;
3554 }
3555
3556 Checksum = fromHex(Checksum);
3557 void *CKMem = Ctx.allocate(Checksum.size(), 1);
3558 memcpy(CKMem, Checksum.data(), Checksum.size());
3559 ArrayRef<uint8_t> ChecksumAsBytes(reinterpret_cast<const uint8_t *>(CKMem),
3560 Checksum.size());
3561
3562 if (!getStreamer().EmitCVFileDirective(FileNumber, Filename, ChecksumAsBytes,
3563 static_cast<uint8_t>(ChecksumKind)))
3564 return Error(FileNumberLoc, "file number already allocated");
3565
3566 return false;
3567}
3568
3569bool AsmParser::parseCVFunctionId(int64_t &FunctionId,
3570 StringRef DirectiveName) {
3571 SMLoc Loc;
3572 return parseTokenLoc(Loc) ||
3573 parseIntToken(FunctionId, "expected function id in '" + DirectiveName +
3574 "' directive") ||
3575 check(FunctionId < 0 || FunctionId >= UINT_MAX(2147483647 *2U +1U), Loc,
3576 "expected function id within range [0, UINT_MAX)");
3577}
3578
3579bool AsmParser::parseCVFileId(int64_t &FileNumber, StringRef DirectiveName) {
3580 SMLoc Loc;
3581 return parseTokenLoc(Loc) ||
3582 parseIntToken(FileNumber, "expected integer in '" + DirectiveName +
3583 "' directive") ||
3584 check(FileNumber < 1, Loc, "file number less than one in '" +
3585 DirectiveName + "' directive") ||
3586 check(!getCVContext().isValidFileNumber(FileNumber), Loc,
3587 "unassigned file number in '" + DirectiveName + "' directive");
3588}
3589
3590/// parseDirectiveCVFuncId
3591/// ::= .cv_func_id FunctionId
3592///
3593/// Introduces a function ID that can be used with .cv_loc.
3594bool AsmParser::parseDirectiveCVFuncId() {
3595 SMLoc FunctionIdLoc = getTok().getLoc();
3596 int64_t FunctionId;
3597
3598 if (parseCVFunctionId(FunctionId, ".cv_func_id") ||
3599 parseToken(AsmToken::EndOfStatement,
3600 "unexpected token in '.cv_func_id' directive"))
3601 return true;
3602
3603 if (!getStreamer().EmitCVFuncIdDirective(FunctionId))
3604 return Error(FunctionIdLoc, "function id already allocated");
3605
3606 return false;
3607}
3608
3609/// parseDirectiveCVInlineSiteId
3610/// ::= .cv_inline_site_id FunctionId
3611/// "within" IAFunc
3612/// "inlined_at" IAFile IALine [IACol]
3613///
3614/// Introduces a function ID that can be used with .cv_loc. Includes "inlined
3615/// at" source location information for use in the line table of the caller,
3616/// whether the caller is a real function or another inlined call site.
3617bool AsmParser::parseDirectiveCVInlineSiteId() {
3618 SMLoc FunctionIdLoc = getTok().getLoc();
3619 int64_t FunctionId;
3620 int64_t IAFunc;
3621 int64_t IAFile;
3622 int64_t IALine;
3623 int64_t IACol = 0;
3624
3625 // FunctionId
3626 if (parseCVFunctionId(FunctionId, ".cv_inline_site_id"))
3627 return true;
3628
3629 // "within"
3630 if (check((getLexer().isNot(AsmToken::Identifier) ||
3631 getTok().getIdentifier() != "within"),
3632 "expected 'within' identifier in '.cv_inline_site_id' directive"))
3633 return true;
3634 Lex();
3635
3636 // IAFunc
3637 if (parseCVFunctionId(IAFunc, ".cv_inline_site_id"))
3638 return true;
3639
3640 // "inlined_at"
3641 if (check((getLexer().isNot(AsmToken::Identifier) ||
3642 getTok().getIdentifier() != "inlined_at"),
3643 "expected 'inlined_at' identifier in '.cv_inline_site_id' "
3644 "directive") )
3645 return true;
3646 Lex();
3647
3648 // IAFile IALine
3649 if (parseCVFileId(IAFile, ".cv_inline_site_id") ||
3650 parseIntToken(IALine, "expected line number after 'inlined_at'"))
3651 return true;
3652
3653 // [IACol]
3654 if (getLexer().is(AsmToken::Integer)) {
3655 IACol = getTok().getIntVal();
3656 Lex();
3657 }
3658
3659 if (parseToken(AsmToken::EndOfStatement,
3660 "unexpected token in '.cv_inline_site_id' directive"))
3661 return true;
3662
3663 if (!getStreamer().EmitCVInlineSiteIdDirective(FunctionId, IAFunc, IAFile,
3664 IALine, IACol, FunctionIdLoc))
3665 return Error(FunctionIdLoc, "function id already allocated");
3666
3667 return false;
3668}
3669
3670/// parseDirectiveCVLoc
3671/// ::= .cv_loc FunctionId FileNumber [LineNumber] [ColumnPos] [prologue_end]
3672/// [is_stmt VALUE]
3673/// The first number is a file number, must have been previously assigned with
3674/// a .file directive, the second number is the line number and optionally the
3675/// third number is a column position (zero if not specified). The remaining
3676/// optional items are .loc sub-directives.
3677bool AsmParser::parseDirectiveCVLoc() {
3678 SMLoc DirectiveLoc = getTok().getLoc();
3679 int64_t FunctionId, FileNumber;
3680 if (parseCVFunctionId(FunctionId, ".cv_loc") ||
3681 parseCVFileId(FileNumber, ".cv_loc"))
3682 return true;
3683
3684 int64_t LineNumber = 0;
3685 if (getLexer().is(AsmToken::Integer)) {
3686 LineNumber = getTok().getIntVal();
3687 if (LineNumber < 0)
3688 return TokError("line number less than zero in '.cv_loc' directive");
3689 Lex();
3690 }
3691
3692 int64_t ColumnPos = 0;
3693 if (getLexer().is(AsmToken::Integer)) {
3694 ColumnPos = getTok().getIntVal();
3695 if (ColumnPos < 0)
3696 return TokError("column position less than zero in '.cv_loc' directive");
3697 Lex();
3698 }
3699
3700 bool PrologueEnd = false;
3701 uint64_t IsStmt = 0;
3702
3703 auto parseOp = [&]() -> bool {
3704 StringRef Name;
3705 SMLoc Loc = getTok().getLoc();
3706 if (parseIdentifier(Name))
3707 return TokError("unexpected token in '.cv_loc' directive");
3708 if (Name == "prologue_end")
3709 PrologueEnd = true;
3710 else if (Name == "is_stmt") {
3711 Loc = getTok().getLoc();
3712 const MCExpr *Value;
3713 if (parseExpression(Value))
3714 return true;
3715 // The expression must be the constant 0 or 1.
3716 IsStmt = ~0ULL;
3717 if (const auto *MCE = dyn_cast<MCConstantExpr>(Value))
3718 IsStmt = MCE->getValue();
3719
3720 if (IsStmt > 1)
3721 return Error(Loc, "is_stmt value not 0 or 1");
3722 } else {
3723 return Error(Loc, "unknown sub-directive in '.cv_loc' directive");
3724 }
3725 return false;
3726 };
3727
3728 if (parseMany(parseOp, false /*hasComma*/))
3729 return true;
3730
3731 getStreamer().EmitCVLocDirective(FunctionId, FileNumber, LineNumber,
3732 ColumnPos, PrologueEnd, IsStmt, StringRef(),
3733 DirectiveLoc);
3734 return false;
3735}
3736
3737/// parseDirectiveCVLinetable
3738/// ::= .cv_linetable FunctionId, FnStart, FnEnd
3739bool AsmParser::parseDirectiveCVLinetable() {
3740 int64_t FunctionId;
3741 StringRef FnStartName, FnEndName;
3742 SMLoc Loc = getTok().getLoc();
3743 if (parseCVFunctionId(FunctionId, ".cv_linetable") ||
3744 parseToken(AsmToken::Comma,
3745 "unexpected token in '.cv_linetable' directive") ||
3746 parseTokenLoc(Loc) || check(parseIdentifier(FnStartName), Loc,
3747 "expected identifier in directive") ||
3748 parseToken(AsmToken::Comma,
3749 "unexpected token in '.cv_linetable' directive") ||
3750 parseTokenLoc(Loc) || check(parseIdentifier(FnEndName), Loc,
3751 "expected identifier in directive"))
3752 return true;
3753
3754 MCSymbol *FnStartSym = getContext().getOrCreateSymbol(FnStartName);
3755 MCSymbol *FnEndSym = getContext().getOrCreateSymbol(FnEndName);
3756
3757 getStreamer().EmitCVLinetableDirective(FunctionId, FnStartSym, FnEndSym);
3758 return false;
3759}
3760
3761/// parseDirectiveCVInlineLinetable
3762/// ::= .cv_inline_linetable PrimaryFunctionId FileId LineNum FnStart FnEnd
3763bool AsmParser::parseDirectiveCVInlineLinetable() {
3764 int64_t PrimaryFunctionId, SourceFileId, SourceLineNum;
3765 StringRef FnStartName, FnEndName;
3766 SMLoc Loc = getTok().getLoc();
3767 if (parseCVFunctionId(PrimaryFunctionId, ".cv_inline_linetable") ||
3768 parseTokenLoc(Loc) ||
3769 parseIntToken(
3770 SourceFileId,
3771 "expected SourceField in '.cv_inline_linetable' directive") ||
3772 check(SourceFileId <= 0, Loc,
3773 "File id less than zero in '.cv_inline_linetable' directive") ||
3774 parseTokenLoc(Loc) ||
3775 parseIntToken(
3776 SourceLineNum,
3777 "expected SourceLineNum in '.cv_inline_linetable' directive") ||
3778 check(SourceLineNum < 0, Loc,
3779 "Line number less than zero in '.cv_inline_linetable' directive") ||
3780 parseTokenLoc(Loc) || check(parseIdentifier(FnStartName), Loc,
3781 "expected identifier in directive") ||
3782 parseTokenLoc(Loc) || check(parseIdentifier(FnEndName), Loc,
3783 "expected identifier in directive"))
3784 return true;
3785
3786 if (parseToken(AsmToken::EndOfStatement, "Expected End of Statement"))
3787 return true;
3788
3789 MCSymbol *FnStartSym = getContext().getOrCreateSymbol(FnStartName);
3790 MCSymbol *FnEndSym = getContext().getOrCreateSymbol(FnEndName);
3791 getStreamer().EmitCVInlineLinetableDirective(PrimaryFunctionId, SourceFileId,
3792 SourceLineNum, FnStartSym,
3793 FnEndSym);
3794 return false;
3795}
3796
3797/// parseDirectiveCVDefRange
3798/// ::= .cv_def_range RangeStart RangeEnd (GapStart GapEnd)*, bytes*
3799bool AsmParser::parseDirectiveCVDefRange() {
3800 SMLoc Loc;
3801 std::vector<std::pair<const MCSymbol *, const MCSymbol *>> Ranges;
3802 while (getLexer().is(AsmToken::Identifier)) {
3803 Loc = getLexer().getLoc();
3804 StringRef GapStartName;
3805 if (parseIdentifier(GapStartName))
3806 return Error(Loc, "expected identifier in directive");
3807 MCSymbol *GapStartSym = getContext().getOrCreateSymbol(GapStartName);
3808
3809 Loc = getLexer().getLoc();
3810 StringRef GapEndName;
3811 if (parseIdentifier(GapEndName))
3812 return Error(Loc, "expected identifier in directive");
3813 MCSymbol *GapEndSym = getContext().getOrCreateSymbol(GapEndName);
3814
3815 Ranges.push_back({GapStartSym, GapEndSym});
3816 }
3817
3818 std::string FixedSizePortion;
3819 if (parseToken(AsmToken::Comma, "unexpected token in directive") ||
3820 parseEscapedString(FixedSizePortion))
3821 return true;
3822
3823 getStreamer().EmitCVDefRangeDirective(Ranges, FixedSizePortion);
3824 return false;
3825}
3826
3827/// parseDirectiveCVString
3828/// ::= .cv_stringtable "string"
3829bool AsmParser::parseDirectiveCVString() {
3830 std::string Data;
3831 if (checkForValidSection() || parseEscapedString(Data))
3832 return addErrorSuffix(" in '.cv_string' directive");
3833
3834 // Put the string in the table and emit the offset.
3835 std::pair<StringRef, unsigned> Insertion =
3836 getCVContext().addToStringTable(Data);
3837 getStreamer().EmitIntValue(Insertion.second, 4);
3838 return false;
3839}
3840
3841/// parseDirectiveCVStringTable
3842/// ::= .cv_stringtable
3843bool AsmParser::parseDirectiveCVStringTable() {
3844 getStreamer().EmitCVStringTableDirective();
3845 return false;
3846}
3847
3848/// parseDirectiveCVFileChecksums
3849/// ::= .cv_filechecksums
3850bool AsmParser::parseDirectiveCVFileChecksums() {
3851 getStreamer().EmitCVFileChecksumsDirective();
3852 return false;
3853}
3854
3855/// parseDirectiveCVFileChecksumOffset
3856/// ::= .cv_filechecksumoffset fileno
3857bool AsmParser::parseDirectiveCVFileChecksumOffset() {
3858 int64_t FileNo;
3859 if (parseIntToken(FileNo, "expected identifier in directive"))
3860 return true;
3861 if (parseToken(AsmToken::EndOfStatement, "Expected End of Statement"))
3862 return true;
3863 getStreamer().EmitCVFileChecksumOffsetDirective(FileNo);
3864 return false;
3865}
3866
3867/// parseDirectiveCVFPOData
3868/// ::= .cv_fpo_data procsym
3869bool AsmParser::parseDirectiveCVFPOData() {
3870 SMLoc DirLoc = getLexer().getLoc();
3871 StringRef ProcName;
3872 if (parseIdentifier(ProcName))
3873 return TokError("expected symbol name");
3874 if (parseEOL("unexpected tokens"))
3875 return addErrorSuffix(" in '.cv_fpo_data' directive");
3876 MCSymbol *ProcSym = getContext().getOrCreateSymbol(ProcName);
3877 getStreamer().EmitCVFPOData(ProcSym, DirLoc);
3878 return false;
3879}
3880
3881/// parseDirectiveCFISections
3882/// ::= .cfi_sections section [, section]
3883bool AsmParser::parseDirectiveCFISections() {
3884 StringRef Name;
3885 bool EH = false;
3886 bool Debug = false;
3887
3888 if (parseIdentifier(Name))
3889 return TokError("Expected an identifier");
3890
3891 if (Name == ".eh_frame")
3892 EH = true;
3893 else if (Name == ".debug_frame")
3894 Debug = true;
3895
3896 if (getLexer().is(AsmToken::Comma)) {
3897 Lex();
3898
3899 if (parseIdentifier(Name))
3900 return TokError("Expected an identifier");
3901
3902 if (Name == ".eh_frame")
3903 EH = true;
3904 else if (Name == ".debug_frame")
3905 Debug = true;
3906 }
3907
3908 getStreamer().EmitCFISections(EH, Debug);
3909 return false;
3910}
3911
3912/// parseDirectiveCFIStartProc
3913/// ::= .cfi_startproc [simple]
3914bool AsmParser::parseDirectiveCFIStartProc() {
3915 StringRef Simple;
3916 if (!parseOptionalToken(AsmToken::EndOfStatement)) {
3917 if (check(parseIdentifier(Simple) || Simple != "simple",
3918 "unexpected token") ||
3919 parseToken(AsmToken::EndOfStatement))
3920 return addErrorSuffix(" in '.cfi_startproc' directive");
3921 }
3922
3923 // TODO(kristina): Deal with a corner case of incorrect diagnostic context
3924 // being produced if this directive is emitted as part of preprocessor macro
3925 // expansion which can *ONLY* happen if Clang's cc1as is the API consumer.
3926 // Tools like llvm-mc on the other hand are not affected by it, and report
3927 // correct context information.
3928 getStreamer().EmitCFIStartProc(!Simple.empty(), Lexer.getLoc());
3929 return false;
3930}
3931
3932/// parseDirectiveCFIEndProc
3933/// ::= .cfi_endproc
3934bool AsmParser::parseDirectiveCFIEndProc() {
3935 getStreamer().EmitCFIEndProc();
3936 return false;
3937}
3938
3939/// parse register name or number.
3940bool AsmParser::parseRegisterOrRegisterNumber(int64_t &Register,
3941 SMLoc DirectiveLoc) {
3942 unsigned RegNo;
3943
3944 if (getLexer().isNot(AsmToken::Integer)) {
3945 if (getTargetParser().ParseRegister(RegNo, DirectiveLoc, DirectiveLoc))
3946 return true;
3947 Register = getContext().getRegisterInfo()->getDwarfRegNum(RegNo, true);
3948 } else
3949 return parseAbsoluteExpression(Register);
3950
3951 return false;
3952}
3953
3954/// parseDirectiveCFIDefCfa
3955/// ::= .cfi_def_cfa register, offset
3956bool AsmParser::parseDirectiveCFIDefCfa(SMLoc DirectiveLoc) {
3957 int64_t Register = 0, Offset = 0;
3958 if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) ||
3959 parseToken(AsmToken::Comma, "unexpected token in directive") ||
3960 parseAbsoluteExpression(Offset))
3961 return true;
3962
3963 getStreamer().EmitCFIDefCfa(Register, Offset);
3964 return false;
3965}
3966
3967/// parseDirectiveCFIDefCfaOffset
3968/// ::= .cfi_def_cfa_offset offset
3969bool AsmParser::parseDirectiveCFIDefCfaOffset() {
3970 int64_t Offset = 0;
3971 if (parseAbsoluteExpression(Offset))
3972 return true;
3973
3974 getStreamer().EmitCFIDefCfaOffset(Offset);
3975 return false;
3976}
3977
3978/// parseDirectiveCFIRegister
3979/// ::= .cfi_register register, register
3980bool AsmParser::parseDirectiveCFIRegister(SMLoc DirectiveLoc) {
3981 int64_t Register1 = 0, Register2 = 0;
3982 if (parseRegisterOrRegisterNumber(Register1, DirectiveLoc) ||
3983 parseToken(AsmToken::Comma, "unexpected token in directive") ||
3984 parseRegisterOrRegisterNumber(Register2, DirectiveLoc))
3985 return true;
3986
3987 getStreamer().EmitCFIRegister(Register1, Register2);
3988 return false;
3989}
3990
3991/// parseDirectiveCFIWindowSave
3992/// ::= .cfi_window_save
3993bool AsmParser::parseDirectiveCFIWindowSave() {
3994 getStreamer().EmitCFIWindowSave();
3995 return false;
3996}
3997
3998/// parseDirectiveCFIAdjustCfaOffset
3999/// ::= .cfi_adjust_cfa_offset adjustment
4000bool AsmParser::parseDirectiveCFIAdjustCfaOffset() {
4001 int64_t Adjustment = 0;
4002 if (parseAbsoluteExpression(Adjustment))
4003 return true;
4004
4005 getStreamer().EmitCFIAdjustCfaOffset(Adjustment);
4006 return false;
4007}
4008
4009/// parseDirectiveCFIDefCfaRegister
4010/// ::= .cfi_def_cfa_register register
4011bool AsmParser::parseDirectiveCFIDefCfaRegister(SMLoc DirectiveLoc) {
4012 int64_t Register = 0;
4013 if (parseRegisterOrRegisterNumber(Register, DirectiveLoc))
4014 return true;
4015
4016 getStreamer().EmitCFIDefCfaRegister(Register);
4017 return false;
4018}
4019
4020/// parseDirectiveCFIOffset
4021/// ::= .cfi_offset register, offset
4022bool AsmParser::parseDirectiveCFIOffset(SMLoc DirectiveLoc) {
4023 int64_t Register = 0;
4024 int64_t Offset = 0;
4025
4026 if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) ||
4027 parseToken(AsmToken::Comma, "unexpected token in directive") ||
4028 parseAbsoluteExpression(Offset))
4029 return true;
4030
4031 getStreamer().EmitCFIOffset(Register, Offset);
4032 return false;
4033}
4034
4035/// parseDirectiveCFIRelOffset
4036/// ::= .cfi_rel_offset register, offset
4037bool AsmParser::parseDirectiveCFIRelOffset(SMLoc DirectiveLoc) {
4038 int64_t Register = 0, Offset = 0;
4039
4040 if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) ||
4041 parseToken(AsmToken::Comma, "unexpected token in directive") ||
4042 parseAbsoluteExpression(Offset))
4043 return true;
4044
4045 getStreamer().EmitCFIRelOffset(Register, Offset);
4046 return false;
4047}
4048
4049static bool isValidEncoding(int64_t Encoding) {
4050 if (Encoding & ~0xff)
4051 return false;
4052
4053 if (Encoding == dwarf::DW_EH_PE_omit)
4054 return true;
4055
4056 const unsigned Format = Encoding & 0xf;
4057 if (Format != dwarf::DW_EH_PE_absptr && Format != dwarf::DW_EH_PE_udata2 &&
4058 Format != dwarf::DW_EH_PE_udata4 && Format != dwarf::DW_EH_PE_udata8 &&
4059 Format != dwarf::DW_EH_PE_sdata2 && Format != dwarf::DW_EH_PE_sdata4 &&
4060 Format != dwarf::DW_EH_PE_sdata8 && Format != dwarf::DW_EH_PE_signed)
4061 return false;
4062
4063 const unsigned Application = Encoding & 0x70;
4064 if (Application != dwarf::DW_EH_PE_absptr &&
4065 Application != dwarf::DW_EH_PE_pcrel)
4066 return false;
4067
4068 return true;
4069}
4070
4071/// parseDirectiveCFIPersonalityOrLsda
4072/// IsPersonality true for cfi_personality, false for cfi_lsda
4073/// ::= .cfi_personality encoding, [symbol_name]
4074/// ::= .cfi_lsda encoding, [symbol_name]
4075bool AsmParser::parseDirectiveCFIPersonalityOrLsda(bool IsPersonality) {
4076 int64_t Encoding = 0;
4077 if (parseAbsoluteExpression(Encoding))
4078 return true;
4079 if (Encoding == dwarf::DW_EH_PE_omit)
4080 return false;
4081
4082 StringRef Name;
4083 if (check(!isValidEncoding(Encoding), "unsupported encoding.") ||
4084 parseToken(AsmToken::Comma, "unexpected token in directive") ||
4085 check(parseIdentifier(Name), "expected identifier in directive"))
4086 return true;
4087
4088 MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
4089
4090 if (IsPersonality)
4091 getStreamer().EmitCFIPersonality(Sym, Encoding);
4092 else
4093 getStreamer().EmitCFILsda(Sym, Encoding);
4094 return false;
4095}
4096
4097/// parseDirectiveCFIRememberState
4098/// ::= .cfi_remember_state
4099bool AsmParser::parseDirectiveCFIRememberState() {
4100 getStreamer().EmitCFIRememberState();
4101 return false;
4102}
4103
4104/// parseDirectiveCFIRestoreState
4105/// ::= .cfi_remember_state
4106bool AsmParser::parseDirectiveCFIRestoreState() {
4107 getStreamer().EmitCFIRestoreState();
4108 return false;
4109}
4110
4111/// parseDirectiveCFISameValue
4112/// ::= .cfi_same_value register
4113bool AsmParser::parseDirectiveCFISameValue(SMLoc DirectiveLoc) {
4114 int64_t Register = 0;
4115
4116 if (parseRegisterOrRegisterNumber(Register, DirectiveLoc))
4117 return true;
4118
4119 getStreamer().EmitCFISameValue(Register);
4120 return false;
4121}
4122
4123/// parseDirectiveCFIRestore
4124/// ::= .cfi_restore register
4125bool AsmParser::parseDirectiveCFIRestore(SMLoc DirectiveLoc) {
4126 int64_t Register = 0;
4127 if (parseRegisterOrRegisterNumber(Register, DirectiveLoc))
4128 return true;
4129
4130 getStreamer().EmitCFIRestore(Register);
4131 return false;
4132}
4133
4134/// parseDirectiveCFIEscape
4135/// ::= .cfi_escape expression[,...]
4136bool AsmParser::parseDirectiveCFIEscape() {
4137 std::string Values;
4138 int64_t CurrValue;
4139 if (parseAbsoluteExpression(CurrValue))
4140 return true;
4141
4142 Values.push_back((uint8_t)CurrValue);
4143
4144 while (getLexer().is(AsmToken::Comma)) {
4145 Lex();
4146
4147 if (parseAbsoluteExpression(CurrValue))
4148 return true;
4149
4150 Values.push_back((uint8_t)CurrValue);
4151 }
4152
4153 getStreamer().EmitCFIEscape(Values);
4154 return false;
4155}
4156
4157/// parseDirectiveCFIReturnColumn
4158/// ::= .cfi_return_column register
4159bool AsmParser::parseDirectiveCFIReturnColumn(SMLoc DirectiveLoc) {
4160 int64_t Register = 0;
4161 if (parseRegisterOrRegisterNumber(Register, DirectiveLoc))
4162 return true;
4163 getStreamer().EmitCFIReturnColumn(Register);
4164 return false;
4165}
4166
4167/// parseDirectiveCFISignalFrame
4168/// ::= .cfi_signal_frame
4169bool AsmParser::parseDirectiveCFISignalFrame() {
4170 if (parseToken(AsmToken::EndOfStatement,
4171 "unexpected token in '.cfi_signal_frame'"))
4172 return true;
4173
4174 getStreamer().EmitCFISignalFrame();
4175 return false;
4176}
4177
4178/// parseDirectiveCFIUndefined
4179/// ::= .cfi_undefined register
4180bool AsmParser::parseDirectiveCFIUndefined(SMLoc DirectiveLoc) {
4181 int64_t Register = 0;
4182
4183 if (parseRegisterOrRegisterNumber(Register, DirectiveLoc))
4184 return true;
4185
4186 getStreamer().EmitCFIUndefined(Register);
4187 return false;
4188}
4189
4190/// parseDirectiveAltmacro
4191/// ::= .altmacro
4192/// ::= .noaltmacro
4193bool AsmParser::parseDirectiveAltmacro(StringRef Directive) {
4194 if (getLexer().isNot(AsmToken::EndOfStatement))
4195 return TokError("unexpected token in '" + Directive + "' directive");
4196 AltMacroMode = (Directive == ".altmacro");
4197 return false;
4198}
4199
4200/// parseDirectiveMacrosOnOff
4201/// ::= .macros_on
4202/// ::= .macros_off
4203bool AsmParser::parseDirectiveMacrosOnOff(StringRef Directive) {
4204 if (parseToken(AsmToken::EndOfStatement,
4205 "unexpected token in '" + Directive + "' directive"))
4206 return true;
4207
4208 setMacrosEnabled(Directive == ".macros_on");
4209 return false;
4210}
4211
4212/// parseDirectiveMacro
4213/// ::= .macro name[,] [parameters]
4214bool AsmParser::parseDirectiveMacro(SMLoc DirectiveLoc) {
4215 StringRef Name;
4216 if (parseIdentifier(Name))
4217 return TokError("expected identifier in '.macro' directive");
4218
4219 if (getLexer().is(AsmToken::Comma))
4220 Lex();
4221
4222 MCAsmMacroParameters Parameters;
4223 while (getLexer().isNot(AsmToken::EndOfStatement)) {
4224
4225 if (!Parameters.empty() && Parameters.back().Vararg)
4226 return Error(Lexer.getLoc(),
4227 "Vararg parameter '" + Parameters.back().Name +
4228 "' should be last one in the list of parameters.");
4229
4230 MCAsmMacroParameter Parameter;
4231 if (parseIdentifier(Parameter.Name))
4232 return TokError("expected identifier in '.macro' directive");
4233
4234 // Emit an error if two (or more) named parameters share the same name
4235 for (const MCAsmMacroParameter& CurrParam : Parameters)
4236 if (CurrParam.Name.equals(Parameter.Name))
4237 return TokError("macro '" + Name + "' has multiple parameters"
4238 " named '" + Parameter.Name + "'");
4239
4240 if (Lexer.is(AsmToken::Colon)) {
4241 Lex(); // consume ':'
4242
4243 SMLoc QualLoc;
4244 StringRef Qualifier;
4245
4246 QualLoc = Lexer.getLoc();
4247 if (parseIdentifier(Qualifier))
4248 return Error(QualLoc, "missing parameter qualifier for "
4249 "'" + Parameter.Name + "' in macro '" + Name + "'");
4250
4251 if (Qualifier == "req")
4252 Parameter.Required = true;
4253 else if (Qualifier == "vararg")
4254 Parameter.Vararg = true;
4255 else
4256 return Error(QualLoc, Qualifier + " is not a valid parameter qualifier "
4257 "for '" + Parameter.Name + "' in macro '" + Name + "'");
4258 }
4259
4260 if (getLexer().is(AsmToken::Equal)) {
4261 Lex();
4262
4263 SMLoc ParamLoc;
4264
4265 ParamLoc = Lexer.getLoc();
4266 if (parseMacroArgument(Parameter.Value, /*Vararg=*/false ))
4267 return true;
4268
4269 if (Parameter.Required)
4270 Warning(ParamLoc, "pointless default value for required parameter "
4271 "'" + Parameter.Name + "' in macro '" + Name + "'");
4272 }
4273
4274 Parameters.push_back(std::move(Parameter));
4275
4276 if (getLexer().is(AsmToken::Comma))
4277 Lex();
4278 }
4279
4280 // Eat just the end of statement.
4281 Lexer.Lex();
4282
4283 // Consuming deferred text, so use Lexer.Lex to ignore Lexing Errors
4284 AsmToken EndToken, StartToken = getTok();
4285 unsigned MacroDepth = 0;
4286 // Lex the macro definition.
4287 while (true) {
4288 // Ignore Lexing errors in macros.
4289 while (Lexer.is(AsmToken::Error)) {
4290 Lexer.Lex();
4291 }
4292
4293 // Check whether we have reached the end of the file.
4294 if (getLexer().is(AsmToken::Eof))
4295 return Error(DirectiveLoc, "no matching '.endmacro' in definition");
4296
4297 // Otherwise, check whether we have reach the .endmacro.
4298 if (getLexer().is(AsmToken::Identifier)) {
4299 if (getTok().getIdentifier() == ".endm" ||
4300 getTok().getIdentifier() == ".endmacro") {
4301 if (MacroDepth == 0) { // Outermost macro.
4302 EndToken = getTok();
4303 Lexer.Lex();
4304 if (getLexer().isNot(AsmToken::EndOfStatement))
4305 return TokError("unexpected token in '" + EndToken.getIdentifier() +
4306 "' directive");
4307 break;
4308 } else {
4309 // Otherwise we just found the end of an inner macro.
4310 --MacroDepth;
4311 }
4312 } else if (getTok().getIdentifier() == ".macro") {
4313 // We allow nested macros. Those aren't instantiated until the outermost
4314 // macro is expanded so just ignore them for now.
4315 ++MacroDepth;
4316 }
4317 }
4318
4319 // Otherwise, scan til the end of the statement.
4320 eatToEndOfStatement();
4321 }
4322
4323 if (getContext().lookupMacro(Name)) {
4324 return Error(DirectiveLoc, "macro '" + Name + "' is already defined");
4325 }
4326
4327 const char *BodyStart = StartToken.getLoc().getPointer();
4328 const char *BodyEnd = EndToken.getLoc().getPointer();
4329 StringRef Body = StringRef(BodyStart, BodyEnd - BodyStart);
4330 checkForBadMacro(DirectiveLoc, Name, Body, Parameters);
4331 MCAsmMacro Macro(Name, Body, std::move(Parameters));
4332 DEBUG_WITH_TYPE("asm-macros", dbgs() << "Defining new macro:\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("asm-macros")) { dbgs() << "Defining new macro:\n"; Macro
.dump(); } } while (false)
4333 Macro.dump())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("asm-macros")) { dbgs() << "Defining new macro:\n"; Macro
.dump(); } } while (false)
;
4334 getContext().defineMacro(Name, std::move(Macro));
4335 return false;
4336}
4337
4338/// checkForBadMacro
4339///
4340/// With the support added for named parameters there may be code out there that
4341/// is transitioning from positional parameters. In versions of gas that did
4342/// not support named parameters they would be ignored on the macro definition.
4343/// But to support both styles of parameters this is not possible so if a macro
4344/// definition has named parameters but does not use them and has what appears
4345/// to be positional parameters, strings like $1, $2, ... and $n, then issue a
4346/// warning that the positional parameter found in body which have no effect.
4347/// Hoping the developer will either remove the named parameters from the macro
4348/// definition so the positional parameters get used if that was what was
4349/// intended or change the macro to use the named parameters. It is possible
4350/// this warning will trigger when the none of the named parameters are used
4351/// and the strings like $1 are infact to simply to be passed trough unchanged.
4352void AsmParser::checkForBadMacro(SMLoc DirectiveLoc, StringRef Name,
4353 StringRef Body,
4354 ArrayRef<MCAsmMacroParameter> Parameters) {
4355 // If this macro is not defined with named parameters the warning we are
4356 // checking for here doesn't apply.
4357 unsigned NParameters = Parameters.size();
4358 if (NParameters == 0)
4359 return;
4360
4361 bool NamedParametersFound = false;
4362 bool PositionalParametersFound = false;
4363
4364 // Look at the body of the macro for use of both the named parameters and what
4365 // are likely to be positional parameters. This is what expandMacro() is
4366 // doing when it finds the parameters in the body.
4367 while (!Body.empty()) {
4368 // Scan for the next possible parameter.
4369 std::size_t End = Body.size(), Pos = 0;
4370 for (; Pos != End; ++Pos) {
4371 // Check for a substitution or escape.
4372 // This macro is defined with parameters, look for \foo, \bar, etc.
4373 if (Body[Pos] == '\\' && Pos + 1 != End)
4374 break;
4375
4376 // This macro should have parameters, but look for $0, $1, ..., $n too.
4377 if (Body[Pos] != '$' || Pos + 1 == End)
4378 continue;
4379 char Next = Body[Pos + 1];
4380 if (Next == '$' || Next == 'n' ||
4381 isdigit(static_cast<unsigned char>(Next)))
4382 break;
4383 }
4384
4385 // Check if we reached the end.
4386 if (Pos == End)
4387 break;
4388
4389 if (Body[Pos] == '$') {
4390 switch (Body[Pos + 1]) {
4391 // $$ => $
4392 case '$':
4393 break;
4394
4395 // $n => number of arguments
4396 case 'n':
4397 PositionalParametersFound = true;
4398 break;
4399
4400 // $[0-9] => argument
4401 default: {
4402 PositionalParametersFound = true;
4403 break;
4404 }
4405 }
4406 Pos += 2;
4407 } else {
4408 unsigned I = Pos + 1;
4409 while (isIdentifierChar(Body[I]) && I + 1 != End)
4410 ++I;
4411
4412 const char *Begin = Body.data() + Pos + 1;
4413 StringRef Argument(Begin, I - (Pos + 1));
4414 unsigned Index = 0;
4415 for (; Index < NParameters; ++Index)
4416 if (Parameters[Index].Name == Argument)
4417 break;
4418
4419 if (Index == NParameters) {
4420 if (Body[Pos + 1] == '(' && Body[Pos + 2] == ')')
4421 Pos += 3;
4422 else {
4423 Pos = I;
4424 }
4425 } else {
4426 NamedParametersFound = true;
4427 Pos += 1 + Argument.size();
4428 }
4429 }
4430 // Update the scan point.
4431 Body = Body.substr(Pos);
4432 }
4433
4434 if (!NamedParametersFound && PositionalParametersFound)
4435 Warning(DirectiveLoc, "macro defined with named parameters which are not "
4436 "used in macro body, possible positional parameter "
4437 "found in body which will have no effect");
4438}
4439
4440/// parseDirectiveExitMacro
4441/// ::= .exitm
4442bool AsmParser::parseDirectiveExitMacro(StringRef Directive) {
4443 if (parseToken(AsmToken::EndOfStatement,
4444 "unexpected token in '" + Directive + "' directive"))
4445 return true;
4446
4447 if (!isInsideMacroInstantiation())
4448 return TokError("unexpected '" + Directive + "' in file, "
4449 "no current macro definition");
4450
4451 // Exit all conditionals that are active in the current macro.
4452 while (TheCondStack.size() != ActiveMacros.back()->CondStackDepth) {
4453 TheCondState = TheCondStack.back();
4454 TheCondStack.pop_back();
4455 }
4456
4457 handleMacroExit();
4458 return false;
4459}
4460
4461/// parseDirectiveEndMacro
4462/// ::= .endm
4463/// ::= .endmacro
4464bool AsmParser::parseDirectiveEndMacro(StringRef Directive) {
4465 if (getLexer().isNot(AsmToken::EndOfStatement))
4466 return TokError("unexpected token in '" + Directive + "' directive");
4467
4468 // If we are inside a macro instantiation, terminate the current
4469 // instantiation.
4470 if (isInsideMacroInstantiation()) {
4471 handleMacroExit();
4472 return false;
4473 }
4474
4475 // Otherwise, this .endmacro is a stray entry in the file; well formed
4476 // .endmacro directives are handled during the macro definition parsing.
4477 return TokError("unexpected '" + Directive + "' in file, "
4478 "no current macro definition");
4479}
4480
4481/// parseDirectivePurgeMacro
4482/// ::= .purgem
4483bool AsmParser::parseDirectivePurgeMacro(SMLoc DirectiveLoc) {
4484 StringRef Name;
4485 SMLoc Loc;
4486 if (parseTokenLoc(Loc) ||
4487 check(parseIdentifier(Name), Loc,
4488 "expected identifier in '.purgem' directive") ||
4489 parseToken(AsmToken::EndOfStatement,
4490 "unexpected token in '.purgem' directive"))
4491 return true;
4492
4493 if (!getContext().lookupMacro(Name))
4494 return Error(DirectiveLoc, "macro '" + Name + "' is not defined");
4495
4496 getContext().undefineMacro(Name);
4497 DEBUG_WITH_TYPE("asm-macros", dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("asm-macros")) { dbgs() << "Un-defining macro: " <<
Name << "\n"; } } while (false)
4498 << "Un-defining macro: " << Name << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("asm-macros")) { dbgs() << "Un-defining macro: " <<
Name << "\n"; } } while (false)
;
4499 return false;
4500}
4501
4502/// parseDirectiveBundleAlignMode
4503/// ::= {.bundle_align_mode} expression
4504bool AsmParser::parseDirectiveBundleAlignMode() {
4505 // Expect a single argument: an expression that evaluates to a constant
4506 // in the inclusive range 0-30.
4507 SMLoc ExprLoc = getLexer().getLoc();
4508 int64_t AlignSizePow2;
4509 if (checkForValidSection() || parseAbsoluteExpression(AlignSizePow2) ||
4510 parseToken(AsmToken::EndOfStatement, "unexpected token after expression "
4511 "in '.bundle_align_mode' "
4512 "directive") ||
4513 check(AlignSizePow2 < 0 || AlignSizePow2 > 30, ExprLoc,
4514 "invalid bundle alignment size (expected between 0 and 30)"))
4515 return true;
4516
4517 // Because of AlignSizePow2's verified range we can safely truncate it to
4518 // unsigned.
4519 getStreamer().EmitBundleAlignMode(static_cast<unsigned>(AlignSizePow2));
4520 return false;
4521}
4522
4523/// parseDirectiveBundleLock
4524/// ::= {.bundle_lock} [align_to_end]
4525bool AsmParser::parseDirectiveBundleLock() {
4526 if (checkForValidSection())
4527 return true;
4528 bool AlignToEnd = false;
4529
4530 StringRef Option;
4531 SMLoc Loc = getTok().getLoc();
4532 const char *kInvalidOptionError =
4533 "invalid option for '.bundle_lock' directive";
4534
4535 if (!parseOptionalToken(AsmToken::EndOfStatement)) {
4536 if (check(parseIdentifier(Option), Loc, kInvalidOptionError) ||
4537 check(Option != "align_to_end", Loc, kInvalidOptionError) ||
4538 parseToken(AsmToken::EndOfStatement,
4539 "unexpected token after '.bundle_lock' directive option"))
4540 return true;
4541 AlignToEnd = true;
4542 }
4543
4544 getStreamer().EmitBundleLock(AlignToEnd);
4545 return false;
4546}
4547
4548/// parseDirectiveBundleLock
4549/// ::= {.bundle_lock}
4550bool AsmParser::parseDirectiveBundleUnlock() {
4551 if (checkForValidSection() ||
4552 parseToken(AsmToken::EndOfStatement,
4553 "unexpected token in '.bundle_unlock' directive"))
4554 return true;
4555
4556 getStreamer().EmitBundleUnlock();
4557 return false;
4558}
4559
4560/// parseDirectiveSpace
4561/// ::= (.skip | .space) expression [ , expression ]
4562bool AsmParser::parseDirectiveSpace(StringRef IDVal) {
4563 SMLoc NumBytesLoc = Lexer.getLoc();
4564 const MCExpr *NumBytes;
4565 if (checkForValidSection() || parseExpression(NumBytes))
4566 return true;
4567
4568 int64_t FillExpr = 0;
4569 if (parseOptionalToken(AsmToken::Comma))
4570 if (parseAbsoluteExpression(FillExpr))
4571 return addErrorSuffix("in '" + Twine(IDVal) + "' directive");
4572 if (parseToken(AsmToken::EndOfStatement))
4573 return addErrorSuffix("in '" + Twine(IDVal) + "' directive");
4574
4575 // FIXME: Sometimes the fill expr is 'nop' if it isn't supplied, instead of 0.
4576 getStreamer().emitFill(*NumBytes, FillExpr, NumBytesLoc);
4577
4578 return false;
4579}
4580
4581/// parseDirectiveDCB
4582/// ::= .dcb.{b, l, w} expression, expression
4583bool AsmParser::parseDirectiveDCB(StringRef IDVal, unsigned Size) {
4584 SMLoc NumValuesLoc = Lexer.getLoc();
4585 int64_t NumValues;
4586 if (checkForValidSection() || parseAbsoluteExpression(NumValues))
4587 return true;
4588
4589 if (NumValues < 0) {
4590 Warning(NumValuesLoc, "'" + Twine(IDVal) + "' directive with negative repeat count has no effect");
4591 return false;
4592 }
4593
4594 if (parseToken(AsmToken::Comma,
4595 "unexpected token in '" + Twine(IDVal) + "' directive"))
4596 return true;
4597
4598 const MCExpr *Value;
4599 SMLoc ExprLoc = getLexer().getLoc();
4600 if (parseExpression(Value))
4601 return true;
4602
4603 // Special case constant expressions to match code generator.
4604 if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value)) {
4605 assert(Size <= 8 && "Invalid size")((Size <= 8 && "Invalid size") ? static_cast<void
> (0) : __assert_fail ("Size <= 8 && \"Invalid size\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 4605, __PRETTY_FUNCTION__))
;
4606 uint64_t IntValue = MCE->getValue();
4607 if (!isUIntN(8 * Size, IntValue) && !isIntN(8 * Size, IntValue))
4608 return Error(ExprLoc, "literal value out of range for directive");
4609 for (uint64_t i = 0, e = NumValues; i != e; ++i)
4610 getStreamer().EmitIntValue(IntValue, Size);
4611 } else {
4612 for (uint64_t i = 0, e = NumValues; i != e; ++i)
4613 getStreamer().EmitValue(Value, Size, ExprLoc);
4614 }
4615
4616 if (parseToken(AsmToken::EndOfStatement,
4617 "unexpected token in '" + Twine(IDVal) + "' directive"))
4618 return true;
4619
4620 return false;
4621}
4622
4623/// parseDirectiveRealDCB
4624/// ::= .dcb.{d, s} expression, expression
4625bool AsmParser::parseDirectiveRealDCB(StringRef IDVal, const fltSemantics &Semantics) {
4626 SMLoc NumValuesLoc = Lexer.getLoc();
4627 int64_t NumValues;
4628 if (checkForValidSection() || parseAbsoluteExpression(NumValues))
4629 return true;
4630
4631 if (NumValues < 0) {
4632 Warning(NumValuesLoc, "'" + Twine(IDVal) + "' directive with negative repeat count has no effect");
4633 return false;
4634 }
4635
4636 if (parseToken(AsmToken::Comma,
4637 "unexpected token in '" + Twine(IDVal) + "' directive"))
4638 return true;
4639
4640 APInt AsInt;
4641 if (parseRealValue(Semantics, AsInt))
4642 return true;
4643
4644 if (parseToken(AsmToken::EndOfStatement,
4645 "unexpected token in '" + Twine(IDVal) + "' directive"))
4646 return true;
4647
4648 for (uint64_t i = 0, e = NumValues; i != e; ++i)
4649 getStreamer().EmitIntValue(AsInt.getLimitedValue(),
4650 AsInt.getBitWidth() / 8);
4651
4652 return false;
4653}
4654
4655/// parseDirectiveDS
4656/// ::= .ds.{b, d, l, p, s, w, x} expression
4657bool AsmParser::parseDirectiveDS(StringRef IDVal, unsigned Size) {
4658 SMLoc NumValuesLoc = Lexer.getLoc();
4659 int64_t NumValues;
4660 if (checkForValidSection() || parseAbsoluteExpression(NumValues))
4661 return true;
4662
4663 if (NumValues < 0) {
4664 Warning(NumValuesLoc, "'" + Twine(IDVal) + "' directive with negative repeat count has no effect");
4665 return false;
4666 }
4667
4668 if (parseToken(AsmToken::EndOfStatement,
4669 "unexpected token in '" + Twine(IDVal) + "' directive"))
4670 return true;
4671
4672 for (uint64_t i = 0, e = NumValues; i != e; ++i)
4673 getStreamer().emitFill(Size, 0);
4674
4675 return false;
4676}
4677
4678/// parseDirectiveLEB128
4679/// ::= (.sleb128 | .uleb128) [ expression (, expression)* ]
4680bool AsmParser::parseDirectiveLEB128(bool Signed) {
4681 if (checkForValidSection())
4682 return true;
4683
4684 auto parseOp = [&]() -> bool {
4685 const MCExpr *Value;
4686 if (parseExpression(Value))
4687 return true;
4688 if (Signed)
4689 getStreamer().EmitSLEB128Value(Value);
4690 else
4691 getStreamer().EmitULEB128Value(Value);
4692 return false;
4693 };
4694
4695 if (parseMany(parseOp))
4696 return addErrorSuffix(" in directive");
4697
4698 return false;
4699}
4700
4701/// parseDirectiveSymbolAttribute
4702/// ::= { ".globl", ".weak", ... } [ identifier ( , identifier )* ]
4703bool AsmParser::parseDirectiveSymbolAttribute(MCSymbolAttr Attr) {
4704 auto parseOp = [&]() -> bool {
4705 StringRef Name;
4706 SMLoc Loc = getTok().getLoc();
4707 if (parseIdentifier(Name))
4708 return Error(Loc, "expected identifier");
4709 MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
4710
4711 // Assembler local symbols don't make any sense here. Complain loudly.
4712 if (Sym->isTemporary())
4713 return Error(Loc, "non-local symbol required");
4714
4715 if (!getStreamer().EmitSymbolAttribute(Sym, Attr))
4716 return Error(Loc, "unable to emit symbol attribute");
4717 return false;
4718 };
4719
4720 if (parseMany(parseOp))
4721 return addErrorSuffix(" in directive");
4722 return false;
4723}
4724
4725/// parseDirectiveComm
4726/// ::= ( .comm | .lcomm ) identifier , size_expression [ , align_expression ]
4727bool AsmParser::parseDirectiveComm(bool IsLocal) {
4728 if (checkForValidSection())
4729 return true;
4730
4731 SMLoc IDLoc = getLexer().getLoc();
4732 StringRef Name;
4733 if (parseIdentifier(Name))
4734 return TokError("expected identifier in directive");
4735
4736 // Handle the identifier as the key symbol.
4737 MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
4738
4739 if (getLexer().isNot(AsmToken::Comma))
4740 return TokError("unexpected token in directive");
4741 Lex();
4742
4743 int64_t Size;
4744 SMLoc SizeLoc = getLexer().getLoc();
4745 if (parseAbsoluteExpression(Size))
4746 return true;
4747
4748 int64_t Pow2Alignment = 0;
4749 SMLoc Pow2AlignmentLoc;
4750 if (getLexer().is(AsmToken::Comma)) {
4751 Lex();
4752 Pow2AlignmentLoc = getLexer().getLoc();
4753 if (parseAbsoluteExpression(Pow2Alignment))
4754 return true;
4755
4756 LCOMM::LCOMMType LCOMM = Lexer.getMAI().getLCOMMDirectiveAlignmentType();
4757 if (IsLocal && LCOMM == LCOMM::NoAlignment)
4758 return Error(Pow2AlignmentLoc, "alignment not supported on this target");
4759
4760 // If this target takes alignments in bytes (not log) validate and convert.
4761 if ((!IsLocal && Lexer.getMAI().getCOMMDirectiveAlignmentIsInBytes()) ||
4762 (IsLocal && LCOMM == LCOMM::ByteAlignment)) {
4763 if (!isPowerOf2_64(Pow2Alignment))
4764 return Error(Pow2AlignmentLoc, "alignment must be a power of 2");
4765 Pow2Alignment = Log2_64(Pow2Alignment);
4766 }
4767 }
4768
4769 if (parseToken(AsmToken::EndOfStatement,
4770 "unexpected token in '.comm' or '.lcomm' directive"))
4771 return true;
4772
4773 // NOTE: a size of zero for a .comm should create a undefined symbol
4774 // but a size of .lcomm creates a bss symbol of size zero.
4775 if (Size < 0)
4776 return Error(SizeLoc, "invalid '.comm' or '.lcomm' directive size, can't "
4777 "be less than zero");
4778
4779 // NOTE: The alignment in the directive is a power of 2 value, the assembler
4780 // may internally end up wanting an alignment in bytes.
4781 // FIXME: Diagnose overflow.
4782 if (Pow2Alignment < 0)
4783 return Error(Pow2AlignmentLoc, "invalid '.comm' or '.lcomm' directive "
4784 "alignment, can't be less than zero");
4785
4786 Sym->redefineIfPossible();
4787 if (!Sym->isUndefined())
4788 return Error(IDLoc, "invalid symbol redefinition");
4789
4790 // Create the Symbol as a common or local common with Size and Pow2Alignment
4791 if (IsLocal) {
4792 getStreamer().EmitLocalCommonSymbol(Sym, Size, 1 << Pow2Alignment);
4793 return false;
4794 }
4795
4796 getStreamer().EmitCommonSymbol(Sym, Size, 1 << Pow2Alignment);
4797 return false;
4798}
4799
4800/// parseDirectiveAbort
4801/// ::= .abort [... message ...]
4802bool AsmParser::parseDirectiveAbort() {
4803 // FIXME: Use loc from directive.
4804 SMLoc Loc = getLexer().getLoc();
4805
4806 StringRef Str = parseStringToEndOfStatement();
4807 if (parseToken(AsmToken::EndOfStatement,
4808 "unexpected token in '.abort' directive"))
4809 return true;
4810
4811 if (Str.empty())
4812 return Error(Loc, ".abort detected. Assembly stopping.");
4813 else
4814 return Error(Loc, ".abort '" + Str + "' detected. Assembly stopping.");
4815 // FIXME: Actually abort assembly here.
4816
4817 return false;
4818}
4819
4820/// parseDirectiveInclude
4821/// ::= .include "filename"
4822bool AsmParser::parseDirectiveInclude() {
4823 // Allow the strings to have escaped octal character sequence.
4824 std::string Filename;
4825 SMLoc IncludeLoc = getTok().getLoc();
4826
4827 if (check(getTok().isNot(AsmToken::String),
4828 "expected string in '.include' directive") ||
4829 parseEscapedString(Filename) ||
4830 check(getTok().isNot(AsmToken::EndOfStatement),
4831 "unexpected token in '.include' directive") ||
4832 // Attempt to switch the lexer to the included file before consuming the
4833 // end of statement to avoid losing it when we switch.
4834 check(enterIncludeFile(Filename), IncludeLoc,
4835 "Could not find include file '" + Filename + "'"))
4836 return true;
4837
4838 return false;
4839}
4840
4841/// parseDirectiveIncbin
4842/// ::= .incbin "filename" [ , skip [ , count ] ]
4843bool AsmParser::parseDirectiveIncbin() {
4844 // Allow the strings to have escaped octal character sequence.
4845 std::string Filename;
4846 SMLoc IncbinLoc = getTok().getLoc();
4847 if (check(getTok().isNot(AsmToken::String),
4848 "expected string in '.incbin' directive") ||
4849 parseEscapedString(Filename))
4850 return true;
4851
4852 int64_t Skip = 0;
4853 const MCExpr *Count = nullptr;
4854 SMLoc SkipLoc, CountLoc;
4855 if (parseOptionalToken(AsmToken::Comma)) {
4856 // The skip expression can be omitted while specifying the count, e.g:
4857 // .incbin "filename",,4
4858 if (getTok().isNot(AsmToken::Comma)) {
4859 if (parseTokenLoc(SkipLoc) || parseAbsoluteExpression(Skip))
4860 return true;
4861 }
4862 if (parseOptionalToken(AsmToken::Comma)) {
4863 CountLoc = getTok().getLoc();
4864 if (parseExpression(Count))
4865 return true;
4866 }
4867 }
4868
4869 if (parseToken(AsmToken::EndOfStatement,
4870 "unexpected token in '.incbin' directive"))
4871 return true;
4872
4873 if (check(Skip < 0, SkipLoc, "skip is negative"))
4874 return true;
4875
4876 // Attempt to process the included file.
4877 if (processIncbinFile(Filename, Skip, Count, CountLoc))
4878 return Error(IncbinLoc, "Could not find incbin file '" + Filename + "'");
4879 return false;
4880}
4881
4882/// parseDirectiveIf
4883/// ::= .if{,eq,ge,gt,le,lt,ne} expression
4884bool AsmParser::parseDirectiveIf(SMLoc DirectiveLoc, DirectiveKind DirKind) {
4885 TheCondStack.push_back(TheCondState);
4886 TheCondState.TheCond = AsmCond::IfCond;
4887 if (TheCondState.Ignore) {
4888 eatToEndOfStatement();
4889 } else {
4890 int64_t ExprValue;
4891 if (parseAbsoluteExpression(ExprValue) ||
4892 parseToken(AsmToken::EndOfStatement,
4893 "unexpected token in '.if' directive"))
4894 return true;
4895
4896 switch (DirKind) {
4897 default:
4898 llvm_unreachable("unsupported directive")::llvm::llvm_unreachable_internal("unsupported directive", "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 4898)
;
4899 case DK_IF:
4900 case DK_IFNE:
4901 break;
4902 case DK_IFEQ:
4903 ExprValue = ExprValue == 0;
4904 break;
4905 case DK_IFGE:
4906 ExprValue = ExprValue >= 0;
4907 break;
4908 case DK_IFGT:
4909 ExprValue = ExprValue > 0;
4910 break;
4911 case DK_IFLE:
4912 ExprValue = ExprValue <= 0;
4913 break;
4914 case DK_IFLT:
4915 ExprValue = ExprValue < 0;
4916 break;
4917 }
4918
4919 TheCondState.CondMet = ExprValue;
4920 TheCondState.Ignore = !TheCondState.CondMet;
4921 }
4922
4923 return false;
4924}
4925
4926/// parseDirectiveIfb
4927/// ::= .ifb string
4928bool AsmParser::parseDirectiveIfb(SMLoc DirectiveLoc, bool ExpectBlank) {
4929 TheCondStack.push_back(TheCondState);
4930 TheCondState.TheCond = AsmCond::IfCond;
4931
4932 if (TheCondState.Ignore) {
4933 eatToEndOfStatement();
4934 } else {
4935 StringRef Str = parseStringToEndOfStatement();
4936
4937 if (parseToken(AsmToken::EndOfStatement,
4938 "unexpected token in '.ifb' directive"))
4939 return true;
4940
4941 TheCondState.CondMet = ExpectBlank == Str.empty();
4942 TheCondState.Ignore = !TheCondState.CondMet;
4943 }
4944
4945 return false;
4946}
4947
4948/// parseDirectiveIfc
4949/// ::= .ifc string1, string2
4950/// ::= .ifnc string1, string2
4951bool AsmParser::parseDirectiveIfc(SMLoc DirectiveLoc, bool ExpectEqual) {
4952 TheCondStack.push_back(TheCondState);
4953 TheCondState.TheCond = AsmCond::IfCond;
4954
4955 if (TheCondState.Ignore) {
4956 eatToEndOfStatement();
4957 } else {
4958 StringRef Str1 = parseStringToComma();
4959
4960 if (parseToken(AsmToken::Comma, "unexpected token in '.ifc' directive"))
4961 return true;
4962
4963 StringRef Str2 = parseStringToEndOfStatement();
4964
4965 if (parseToken(AsmToken::EndOfStatement,
4966 "unexpected token in '.ifc' directive"))
4967 return true;
4968
4969 TheCondState.CondMet = ExpectEqual == (Str1.trim() == Str2.trim());
4970 TheCondState.Ignore = !TheCondState.CondMet;
4971 }
4972
4973 return false;
4974}
4975
4976/// parseDirectiveIfeqs
4977/// ::= .ifeqs string1, string2
4978bool AsmParser::parseDirectiveIfeqs(SMLoc DirectiveLoc, bool ExpectEqual) {
4979 if (Lexer.isNot(AsmToken::String)) {
4980 if (ExpectEqual)
4981 return TokError("expected string parameter for '.ifeqs' directive");
4982 return TokError("expected string parameter for '.ifnes' directive");
4983 }
4984
4985 StringRef String1 = getTok().getStringContents();
4986 Lex();
4987
4988 if (Lexer.isNot(AsmToken::Comma)) {
4989 if (ExpectEqual)
4990 return TokError(
4991 "expected comma after first string for '.ifeqs' directive");
4992 return TokError("expected comma after first string for '.ifnes' directive");
4993 }
4994
4995 Lex();
4996
4997 if (Lexer.isNot(AsmToken::String)) {
4998 if (ExpectEqual)
4999 return TokError("expected string parameter for '.ifeqs' directive");
5000 return TokError("expected string parameter for '.ifnes' directive");
5001 }
5002
5003 StringRef String2 = getTok().getStringContents();
5004 Lex();
5005
5006 TheCondStack.push_back(TheCondState);
5007 TheCondState.TheCond = AsmCond::IfCond;
5008 TheCondState.CondMet = ExpectEqual == (String1 == String2);
5009 TheCondState.Ignore = !TheCondState.CondMet;
5010
5011 return false;
5012}
5013
5014/// parseDirectiveIfdef
5015/// ::= .ifdef symbol
5016bool AsmParser::parseDirectiveIfdef(SMLoc DirectiveLoc, bool expect_defined) {
5017 StringRef Name;
5018 TheCondStack.push_back(TheCondState);
5019 TheCondState.TheCond = AsmCond::IfCond;
5020
5021 if (TheCondState.Ignore) {
5022 eatToEndOfStatement();
5023 } else {
5024 if (check(parseIdentifier(Name), "expected identifier after '.ifdef'") ||
5025 parseToken(AsmToken::EndOfStatement, "unexpected token in '.ifdef'"))
5026 return true;
5027
5028 MCSymbol *Sym = getContext().lookupSymbol(Name);
5029
5030 if (expect_defined)
5031 TheCondState.CondMet = (Sym && !Sym->isUndefined());
5032 else
5033 TheCondState.CondMet = (!Sym || Sym->isUndefined());
5034 TheCondState.Ignore = !TheCondState.CondMet;
5035 }
5036
5037 return false;
5038}
5039
5040/// parseDirectiveElseIf
5041/// ::= .elseif expression
5042bool AsmParser::parseDirectiveElseIf(SMLoc DirectiveLoc) {
5043 if (TheCondState.TheCond != AsmCond::IfCond &&
5044 TheCondState.TheCond != AsmCond::ElseIfCond)
5045 return Error(DirectiveLoc, "Encountered a .elseif that doesn't follow an"
5046 " .if or an .elseif");
5047 TheCondState.TheCond = AsmCond::ElseIfCond;
5048
5049 bool LastIgnoreState = false;
5050 if (!TheCondStack.empty())
5051 LastIgnoreState = TheCondStack.back().Ignore;
5052 if (LastIgnoreState || TheCondState.CondMet) {
5053 TheCondState.Ignore = true;
5054 eatToEndOfStatement();
5055 } else {
5056 int64_t ExprValue;
5057 if (parseAbsoluteExpression(ExprValue))
5058 return true;
5059
5060 if (parseToken(AsmToken::EndOfStatement,
5061 "unexpected token in '.elseif' directive"))
5062 return true;
5063
5064 TheCondState.CondMet = ExprValue;
5065 TheCondState.Ignore = !TheCondState.CondMet;
5066 }
5067
5068 return false;
5069}
5070
5071/// parseDirectiveElse
5072/// ::= .else
5073bool AsmParser::parseDirectiveElse(SMLoc DirectiveLoc) {
5074 if (parseToken(AsmToken::EndOfStatement,
5075 "unexpected token in '.else' directive"))
5076 return true;
5077
5078 if (TheCondState.TheCond != AsmCond::IfCond &&
5079 TheCondState.TheCond != AsmCond::ElseIfCond)
5080 return Error(DirectiveLoc, "Encountered a .else that doesn't follow "
5081 " an .if or an .elseif");
5082 TheCondState.TheCond = AsmCond::ElseCond;
5083 bool LastIgnoreState = false;
5084 if (!TheCondStack.empty())
5085 LastIgnoreState = TheCondStack.back().Ignore;
5086 if (LastIgnoreState || TheCondState.CondMet)
5087 TheCondState.Ignore = true;
5088 else
5089 TheCondState.Ignore = false;
5090
5091 return false;
5092}
5093
5094/// parseDirectiveEnd
5095/// ::= .end
5096bool AsmParser::parseDirectiveEnd(SMLoc DirectiveLoc) {
5097 if (parseToken(AsmToken::EndOfStatement,
5098 "unexpected token in '.end' directive"))
5099 return true;
5100
5101 while (Lexer.isNot(AsmToken::Eof))
5102 Lexer.Lex();
5103
5104 return false;
5105}
5106
5107/// parseDirectiveError
5108/// ::= .err
5109/// ::= .error [string]
5110bool AsmParser::parseDirectiveError(SMLoc L, bool WithMessage) {
5111 if (!TheCondStack.empty()) {
5112 if (TheCondStack.back().Ignore) {
5113 eatToEndOfStatement();
5114 return false;
5115 }
5116 }
5117
5118 if (!WithMessage)
5119 return Error(L, ".err encountered");
5120
5121 StringRef Message = ".error directive invoked in source file";
5122 if (Lexer.isNot(AsmToken::EndOfStatement)) {
5123 if (Lexer.isNot(AsmToken::String))
5124 return TokError(".error argument must be a string");
5125
5126 Message = getTok().getStringContents();
5127 Lex();
5128 }
5129
5130 return Error(L, Message);
5131}
5132
5133/// parseDirectiveWarning
5134/// ::= .warning [string]
5135bool AsmParser::parseDirectiveWarning(SMLoc L) {
5136 if (!TheCondStack.empty()) {
5137 if (TheCondStack.back().Ignore) {
5138 eatToEndOfStatement();
5139 return false;
5140 }
5141 }
5142
5143 StringRef Message = ".warning directive invoked in source file";
5144
5145 if (!parseOptionalToken(AsmToken::EndOfStatement)) {
5146 if (Lexer.isNot(AsmToken::String))
5147 return TokError(".warning argument must be a string");
5148
5149 Message = getTok().getStringContents();
5150 Lex();
5151 if (parseToken(AsmToken::EndOfStatement,
5152 "expected end of statement in '.warning' directive"))
5153 return true;
5154 }
5155
5156 return Warning(L, Message);
5157}
5158
5159/// parseDirectiveEndIf
5160/// ::= .endif
5161bool AsmParser::parseDirectiveEndIf(SMLoc DirectiveLoc) {
5162 if (parseToken(AsmToken::EndOfStatement,
5163 "unexpected token in '.endif' directive"))
5164 return true;
5165
5166 if ((TheCondState.TheCond == AsmCond::NoCond) || TheCondStack.empty())
5167 return Error(DirectiveLoc, "Encountered a .endif that doesn't follow "
5168 "an .if or .else");
5169 if (!TheCondStack.empty()) {
5170 TheCondState = TheCondStack.back();
5171 TheCondStack.pop_back();
5172 }
5173
5174 return false;
5175}
5176
5177void AsmParser::initializeDirectiveKindMap() {
5178 DirectiveKindMap[".set"] = DK_SET;
5179 DirectiveKindMap[".equ"] = DK_EQU;
5180 DirectiveKindMap[".equiv"] = DK_EQUIV;
5181 DirectiveKindMap[".ascii"] = DK_ASCII;
5182 DirectiveKindMap[".asciz"] = DK_ASCIZ;
5183 DirectiveKindMap[".string"] = DK_STRING;
5184 DirectiveKindMap[".byte"] = DK_BYTE;
5185 DirectiveKindMap[".short"] = DK_SHORT;
5186 DirectiveKindMap[".value"] = DK_VALUE;
5187 DirectiveKindMap[".2byte"] = DK_2BYTE;
5188 DirectiveKindMap[".long"] = DK_LONG;
5189 DirectiveKindMap[".int"] = DK_INT;
5190 DirectiveKindMap[".4byte"] = DK_4BYTE;
5191 DirectiveKindMap[".quad"] = DK_QUAD;
5192 DirectiveKindMap[".8byte"] = DK_8BYTE;
5193 DirectiveKindMap[".octa"] = DK_OCTA;
5194 DirectiveKindMap[".single"] = DK_SINGLE;
5195 DirectiveKindMap[".float"] = DK_FLOAT;
5196 DirectiveKindMap[".double"] = DK_DOUBLE;
5197 DirectiveKindMap[".align"] = DK_ALIGN;
5198 DirectiveKindMap[".align32"] = DK_ALIGN32;
5199 DirectiveKindMap[".balign"] = DK_BALIGN;
5200 DirectiveKindMap[".balignw"] = DK_BALIGNW;
5201 DirectiveKindMap[".balignl"] = DK_BALIGNL;
5202 DirectiveKindMap[".p2align"] = DK_P2ALIGN;
5203 DirectiveKindMap[".p2alignw"] = DK_P2ALIGNW;
5204 DirectiveKindMap[".p2alignl"] = DK_P2ALIGNL;
5205 DirectiveKindMap[".org"] = DK_ORG;
5206 DirectiveKindMap[".fill"] = DK_FILL;
5207 DirectiveKindMap[".zero"] = DK_ZERO;
5208 DirectiveKindMap[".extern"] = DK_EXTERN;
5209 DirectiveKindMap[".globl"] = DK_GLOBL;
5210 DirectiveKindMap[".global"] = DK_GLOBAL;
5211 DirectiveKindMap[".lazy_reference"] = DK_LAZY_REFERENCE;
5212 DirectiveKindMap[".no_dead_strip"] = DK_NO_DEAD_STRIP;
5213 DirectiveKindMap[".symbol_resolver"] = DK_SYMBOL_RESOLVER;
5214 DirectiveKindMap[".private_extern"] = DK_PRIVATE_EXTERN;
5215 DirectiveKindMap[".reference"] = DK_REFERENCE;
5216 DirectiveKindMap[".weak_definition"] = DK_WEAK_DEFINITION;
5217 DirectiveKindMap[".weak_reference"] = DK_WEAK_REFERENCE;
5218 DirectiveKindMap[".weak_def_can_be_hidden"] = DK_WEAK_DEF_CAN_BE_HIDDEN;
5219 DirectiveKindMap[".comm"] = DK_COMM;
5220 DirectiveKindMap[".common"] = DK_COMMON;
5221 DirectiveKindMap[".lcomm"] = DK_LCOMM;
5222 DirectiveKindMap[".abort"] = DK_ABORT;
5223 DirectiveKindMap[".include"] = DK_INCLUDE;
5224 DirectiveKindMap[".incbin"] = DK_INCBIN;
5225 DirectiveKindMap[".code16"] = DK_CODE16;
5226 DirectiveKindMap[".code16gcc"] = DK_CODE16GCC;
5227 DirectiveKindMap[".rept"] = DK_REPT;
5228 DirectiveKindMap[".rep"] = DK_REPT;
5229 DirectiveKindMap[".irp"] = DK_IRP;
5230 DirectiveKindMap[".irpc"] = DK_IRPC;
5231 DirectiveKindMap[".endr"] = DK_ENDR;
5232 DirectiveKindMap[".bundle_align_mode"] = DK_BUNDLE_ALIGN_MODE;
5233 DirectiveKindMap[".bundle_lock"] = DK_BUNDLE_LOCK;
5234 DirectiveKindMap[".bundle_unlock"] = DK_BUNDLE_UNLOCK;
5235 DirectiveKindMap[".if"] = DK_IF;
5236 DirectiveKindMap[".ifeq"] = DK_IFEQ;
5237 DirectiveKindMap[".ifge"] = DK_IFGE;
5238 DirectiveKindMap[".ifgt"] = DK_IFGT;
5239 DirectiveKindMap[".ifle"] = DK_IFLE;
5240 DirectiveKindMap[".iflt"] = DK_IFLT;
5241 DirectiveKindMap[".ifne"] = DK_IFNE;
5242 DirectiveKindMap[".ifb"] = DK_IFB;
5243 DirectiveKindMap[".ifnb"] = DK_IFNB;
5244 DirectiveKindMap[".ifc"] = DK_IFC;
5245 DirectiveKindMap[".ifeqs"] = DK_IFEQS;
5246 DirectiveKindMap[".ifnc"] = DK_IFNC;
5247 DirectiveKindMap[".ifnes"] = DK_IFNES;
5248 DirectiveKindMap[".ifdef"] = DK_IFDEF;
5249 DirectiveKindMap[".ifndef"] = DK_IFNDEF;
5250 DirectiveKindMap[".ifnotdef"] = DK_IFNOTDEF;
5251 DirectiveKindMap[".elseif"] = DK_ELSEIF;
5252 DirectiveKindMap[".else"] = DK_ELSE;
5253 DirectiveKindMap[".end"] = DK_END;
5254 DirectiveKindMap[".endif"] = DK_ENDIF;
5255 DirectiveKindMap[".skip"] = DK_SKIP;
5256 DirectiveKindMap[".space"] = DK_SPACE;
5257 DirectiveKindMap[".file"] = DK_FILE;
5258 DirectiveKindMap[".line"] = DK_LINE;
5259 DirectiveKindMap[".loc"] = DK_LOC;
5260 DirectiveKindMap[".stabs"] = DK_STABS;
5261 DirectiveKindMap[".cv_file"] = DK_CV_FILE;
5262 DirectiveKindMap[".cv_func_id"] = DK_CV_FUNC_ID;
5263 DirectiveKindMap[".cv_loc"] = DK_CV_LOC;
5264 DirectiveKindMap[".cv_linetable"] = DK_CV_LINETABLE;
5265 DirectiveKindMap[".cv_inline_linetable"] = DK_CV_INLINE_LINETABLE;
5266 DirectiveKindMap[".cv_inline_site_id"] = DK_CV_INLINE_SITE_ID;
5267 DirectiveKindMap[".cv_def_range"] = DK_CV_DEF_RANGE;
5268 DirectiveKindMap[".cv_string"] = DK_CV_STRING;
5269 DirectiveKindMap[".cv_stringtable"] = DK_CV_STRINGTABLE;
5270 DirectiveKindMap[".cv_filechecksums"] = DK_CV_FILECHECKSUMS;
5271 DirectiveKindMap[".cv_filechecksumoffset"] = DK_CV_FILECHECKSUM_OFFSET;
5272 DirectiveKindMap[".cv_fpo_data"] = DK_CV_FPO_DATA;
5273 DirectiveKindMap[".sleb128"] = DK_SLEB128;
5274 DirectiveKindMap[".uleb128"] = DK_ULEB128;
5275 DirectiveKindMap[".cfi_sections"] = DK_CFI_SECTIONS;
5276 DirectiveKindMap[".cfi_startproc"] = DK_CFI_STARTPROC;
5277 DirectiveKindMap[".cfi_endproc"] = DK_CFI_ENDPROC;
5278 DirectiveKindMap[".cfi_def_cfa"] = DK_CFI_DEF_CFA;
5279 DirectiveKindMap[".cfi_def_cfa_offset"] = DK_CFI_DEF_CFA_OFFSET;
5280 DirectiveKindMap[".cfi_adjust_cfa_offset"] = DK_CFI_ADJUST_CFA_OFFSET;
5281 DirectiveKindMap[".cfi_def_cfa_register"] = DK_CFI_DEF_CFA_REGISTER;
5282 DirectiveKindMap[".cfi_offset"] = DK_CFI_OFFSET;
5283 DirectiveKindMap[".cfi_rel_offset"] = DK_CFI_REL_OFFSET;
5284 DirectiveKindMap[".cfi_personality"] = DK_CFI_PERSONALITY;
5285 DirectiveKindMap[".cfi_lsda"] = DK_CFI_LSDA;
5286 DirectiveKindMap[".cfi_remember_state"] = DK_CFI_REMEMBER_STATE;
5287 DirectiveKindMap[".cfi_restore_state"] = DK_CFI_RESTORE_STATE;
5288 DirectiveKindMap[".cfi_same_value"] = DK_CFI_SAME_VALUE;
5289 DirectiveKindMap[".cfi_restore"] = DK_CFI_RESTORE;
5290 DirectiveKindMap[".cfi_escape"] = DK_CFI_ESCAPE;
5291 DirectiveKindMap[".cfi_return_column"] = DK_CFI_RETURN_COLUMN;
5292 DirectiveKindMap[".cfi_signal_frame"] = DK_CFI_SIGNAL_FRAME;
5293 DirectiveKindMap[".cfi_undefined"] = DK_CFI_UNDEFINED;
5294 DirectiveKindMap[".cfi_register"] = DK_CFI_REGISTER;
5295 DirectiveKindMap[".cfi_window_save"] = DK_CFI_WINDOW_SAVE;
5296 DirectiveKindMap[".macros_on"] = DK_MACROS_ON;
5297 DirectiveKindMap[".macros_off"] = DK_MACROS_OFF;
5298 DirectiveKindMap[".macro"] = DK_MACRO;
5299 DirectiveKindMap[".exitm"] = DK_EXITM;
5300 DirectiveKindMap[".endm"] = DK_ENDM;
5301 DirectiveKindMap[".endmacro"] = DK_ENDMACRO;
5302 DirectiveKindMap[".purgem"] = DK_PURGEM;
5303 DirectiveKindMap[".err"] = DK_ERR;
5304 DirectiveKindMap[".error"] = DK_ERROR;
5305 DirectiveKindMap[".warning"] = DK_WARNING;
5306 DirectiveKindMap[".altmacro"] = DK_ALTMACRO;
5307 DirectiveKindMap[".noaltmacro"] = DK_NOALTMACRO;
5308 DirectiveKindMap[".reloc"] = DK_RELOC;
5309 DirectiveKindMap[".dc"] = DK_DC;
5310 DirectiveKindMap[".dc.a"] = DK_DC_A;
5311 DirectiveKindMap[".dc.b"] = DK_DC_B;
5312 DirectiveKindMap[".dc.d"] = DK_DC_D;
5313 DirectiveKindMap[".dc.l"] = DK_DC_L;
5314 DirectiveKindMap[".dc.s"] = DK_DC_S;
5315 DirectiveKindMap[".dc.w"] = DK_DC_W;
5316 DirectiveKindMap[".dc.x"] = DK_DC_X;
5317 DirectiveKindMap[".dcb"] = DK_DCB;
5318 DirectiveKindMap[".dcb.b"] = DK_DCB_B;
5319 DirectiveKindMap[".dcb.d"] = DK_DCB_D;
5320 DirectiveKindMap[".dcb.l"] = DK_DCB_L;
5321 DirectiveKindMap[".dcb.s"] = DK_DCB_S;
5322 DirectiveKindMap[".dcb.w"] = DK_DCB_W;
5323 DirectiveKindMap[".dcb.x"] = DK_DCB_X;
5324 DirectiveKindMap[".ds"] = DK_DS;
5325 DirectiveKindMap[".ds.b"] = DK_DS_B;
5326 DirectiveKindMap[".ds.d"] = DK_DS_D;
5327 DirectiveKindMap[".ds.l"] = DK_DS_L;
5328 DirectiveKindMap[".ds.p"] = DK_DS_P;
5329 DirectiveKindMap[".ds.s"] = DK_DS_S;
5330 DirectiveKindMap[".ds.w"] = DK_DS_W;
5331 DirectiveKindMap[".ds.x"] = DK_DS_X;
5332 DirectiveKindMap[".print"] = DK_PRINT;
5333 DirectiveKindMap[".addrsig"] = DK_ADDRSIG;
5334 DirectiveKindMap[".addrsig_sym"] = DK_ADDRSIG_SYM;
5335}
5336
5337MCAsmMacro *AsmParser::parseMacroLikeBody(SMLoc DirectiveLoc) {
5338 AsmToken EndToken, StartToken = getTok();
5339
5340 unsigned NestLevel = 0;
5341 while (true) {
5342 // Check whether we have reached the end of the file.
5343 if (getLexer().is(AsmToken::Eof)) {
5344 printError(DirectiveLoc, "no matching '.endr' in definition");
5345 return nullptr;
5346 }
5347
5348 if (Lexer.is(AsmToken::Identifier) &&
5349 (getTok().getIdentifier() == ".rep" ||
5350 getTok().getIdentifier() == ".rept" ||
5351 getTok().getIdentifier() == ".irp" ||
5352 getTok().getIdentifier() == ".irpc")) {
5353 ++NestLevel;
5354 }
5355
5356 // Otherwise, check whether we have reached the .endr.
5357 if (Lexer.is(AsmToken::Identifier) && getTok().getIdentifier() == ".endr") {
5358 if (NestLevel == 0) {
5359 EndToken = getTok();
5360 Lex();
5361 if (Lexer.isNot(AsmToken::EndOfStatement)) {
5362 printError(getTok().getLoc(),
5363 "unexpected token in '.endr' directive");
5364 return nullptr;
5365 }
5366 break;
5367 }
5368 --NestLevel;
5369 }
5370
5371 // Otherwise, scan till the end of the statement.
5372 eatToEndOfStatement();
5373 }
5374
5375 const char *BodyStart = StartToken.getLoc().getPointer();
5376 const char *BodyEnd = EndToken.getLoc().getPointer();
5377 StringRef Body = StringRef(BodyStart, BodyEnd - BodyStart);
5378
5379 // We Are Anonymous.
5380 MacroLikeBodies.emplace_back(StringRef(), Body, MCAsmMacroParameters());
5381 return &MacroLikeBodies.back();
5382}
5383
5384void AsmParser::instantiateMacroLikeBody(MCAsmMacro *M, SMLoc DirectiveLoc,
5385 raw_svector_ostream &OS) {
5386 OS << ".endr\n";
5387
5388 std::unique_ptr<MemoryBuffer> Instantiation =
5389 MemoryBuffer::getMemBufferCopy(OS.str(), "<instantiation>");
5390
5391 // Create the macro instantiation object and add to the current macro
5392 // instantiation stack.
5393 MacroInstantiation *MI = new MacroInstantiation(
5394 DirectiveLoc, CurBuffer, getTok().getLoc(), TheCondStack.size());
5395 ActiveMacros.push_back(MI);
5396
5397 // Jump to the macro instantiation and prime the lexer.
5398 CurBuffer = SrcMgr.AddNewSourceBuffer(std::move(Instantiation), SMLoc());
5399 Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer());
5400 Lex();
5401}
5402
5403/// parseDirectiveRept
5404/// ::= .rep | .rept count
5405bool AsmParser::parseDirectiveRept(SMLoc DirectiveLoc, StringRef Dir) {
5406 const MCExpr *CountExpr;
5407 SMLoc CountLoc = getTok().getLoc();
5408 if (parseExpression(CountExpr))
5409 return true;
5410
5411 int64_t Count;
5412 if (!CountExpr->evaluateAsAbsolute(Count, getStreamer().getAssemblerPtr())) {
5413 return Error(CountLoc, "unexpected token in '" + Dir + "' directive");
5414 }
5415
5416 if (check(Count < 0, CountLoc, "Count is negative") ||
5417 parseToken(AsmToken::EndOfStatement,
5418 "unexpected token in '" + Dir + "' directive"))
5419 return true;
5420
5421 // Lex the rept definition.
5422 MCAsmMacro *M = parseMacroLikeBody(DirectiveLoc);
5423 if (!M)
5424 return true;
5425
5426 // Macro instantiation is lexical, unfortunately. We construct a new buffer
5427 // to hold the macro body with substitutions.
5428 SmallString<256> Buf;
5429 raw_svector_ostream OS(Buf);
5430 while (Count--) {
5431 // Note that the AtPseudoVariable is disabled for instantiations of .rep(t).
5432 if (expandMacro(OS, M->Body, None, None, false, getTok().getLoc()))
5433 return true;
5434 }
5435 instantiateMacroLikeBody(M, DirectiveLoc, OS);
5436
5437 return false;
5438}
5439
5440/// parseDirectiveIrp
5441/// ::= .irp symbol,values
5442bool AsmParser::parseDirectiveIrp(SMLoc DirectiveLoc) {
5443 MCAsmMacroParameter Parameter;
5444 MCAsmMacroArguments A;
5445 if (check(parseIdentifier(Parameter.Name),
5446 "expected identifier in '.irp' directive") ||
5447 parseToken(AsmToken::Comma, "expected comma in '.irp' directive") ||
5448 parseMacroArguments(nullptr, A) ||
5449 parseToken(AsmToken::EndOfStatement, "expected End of Statement"))
5450 return true;
5451
5452 // Lex the irp definition.
5453 MCAsmMacro *M = parseMacroLikeBody(DirectiveLoc);
5454 if (!M)
5455 return true;
5456
5457 // Macro instantiation is lexical, unfortunately. We construct a new buffer
5458 // to hold the macro body with substitutions.
5459 SmallString<256> Buf;
5460 raw_svector_ostream OS(Buf);
5461
5462 for (const MCAsmMacroArgument &Arg : A) {
5463 // Note that the AtPseudoVariable is enabled for instantiations of .irp.
5464 // This is undocumented, but GAS seems to support it.
5465 if (expandMacro(OS, M->Body, Parameter, Arg, true, getTok().getLoc()))
5466 return true;
5467 }
5468
5469 instantiateMacroLikeBody(M, DirectiveLoc, OS);
5470
5471 return false;
5472}
5473
5474/// parseDirectiveIrpc
5475/// ::= .irpc symbol,values
5476bool AsmParser::parseDirectiveIrpc(SMLoc DirectiveLoc) {
5477 MCAsmMacroParameter Parameter;
5478 MCAsmMacroArguments A;
5479
5480 if (check(parseIdentifier(Parameter.Name),
5481 "expected identifier in '.irpc' directive") ||
5482 parseToken(AsmToken::Comma, "expected comma in '.irpc' directive") ||
5483 parseMacroArguments(nullptr, A))
5484 return true;
5485
5486 if (A.size() != 1 || A.front().size() != 1)
5487 return TokError("unexpected token in '.irpc' directive");
5488
5489 // Eat the end of statement.
5490 if (parseToken(AsmToken::EndOfStatement, "expected end of statement"))
5491 return true;
5492
5493 // Lex the irpc definition.
5494 MCAsmMacro *M = parseMacroLikeBody(DirectiveLoc);
5495 if (!M)
5496 return true;
5497
5498 // Macro instantiation is lexical, unfortunately. We construct a new buffer
5499 // to hold the macro body with substitutions.
5500 SmallString<256> Buf;
5501 raw_svector_ostream OS(Buf);
5502
5503 StringRef Values = A.front().front().getString();
5504 for (std::size_t I = 0, End = Values.size(); I != End; ++I) {
5505 MCAsmMacroArgument Arg;
5506 Arg.emplace_back(AsmToken::Identifier, Values.slice(I, I + 1));
5507
5508 // Note that the AtPseudoVariable is enabled for instantiations of .irpc.
5509 // This is undocumented, but GAS seems to support it.
5510 if (expandMacro(OS, M->Body, Parameter, Arg, true, getTok().getLoc()))
5511 return true;
5512 }
5513
5514 instantiateMacroLikeBody(M, DirectiveLoc, OS);
5515
5516 return false;
5517}
5518
5519bool AsmParser::parseDirectiveEndr(SMLoc DirectiveLoc) {
5520 if (ActiveMacros.empty())
5521 return TokError("unmatched '.endr' directive");
5522
5523 // The only .repl that should get here are the ones created by
5524 // instantiateMacroLikeBody.
5525 assert(getLexer().is(AsmToken::EndOfStatement))((getLexer().is(AsmToken::EndOfStatement)) ? static_cast<void
> (0) : __assert_fail ("getLexer().is(AsmToken::EndOfStatement)"
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 5525, __PRETTY_FUNCTION__))
;
5526
5527 handleMacroExit();
5528 return false;
5529}
5530
5531bool AsmParser::parseDirectiveMSEmit(SMLoc IDLoc, ParseStatementInfo &Info,
5532 size_t Len) {
5533 const MCExpr *Value;
5534 SMLoc ExprLoc = getLexer().getLoc();
5535 if (parseExpression(Value))
5536 return true;
5537 const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value);
5538 if (!MCE)
5539 return Error(ExprLoc, "unexpected expression in _emit");
5540 uint64_t IntValue = MCE->getValue();
5541 if (!isUInt<8>(IntValue) && !isInt<8>(IntValue))
5542 return Error(ExprLoc, "literal value out of range for directive");
5543
5544 Info.AsmRewrites->emplace_back(AOK_Emit, IDLoc, Len);
5545 return false;
5546}
5547
5548bool AsmParser::parseDirectiveMSAlign(SMLoc IDLoc, ParseStatementInfo &Info) {
5549 const MCExpr *Value;
5550 SMLoc ExprLoc = getLexer().getLoc();
5551 if (parseExpression(Value))
5552 return true;
5553 const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value);
5554 if (!MCE)
5555 return Error(ExprLoc, "unexpected expression in align");
5556 uint64_t IntValue = MCE->getValue();
5557 if (!isPowerOf2_64(IntValue))
5558 return Error(ExprLoc, "literal value not a power of two greater then zero");
5559
5560 Info.AsmRewrites->emplace_back(AOK_Align, IDLoc, 5, Log2_64(IntValue));
5561 return false;
5562}
5563
5564bool AsmParser::parseDirectivePrint(SMLoc DirectiveLoc) {
5565 const AsmToken StrTok = getTok();
5566 Lex();
5567 if (StrTok.isNot(AsmToken::String) || StrTok.getString().front() != '"')
5568 return Error(DirectiveLoc, "expected double quoted string after .print");
5569 if (parseToken(AsmToken::EndOfStatement, "expected end of statement"))
5570 return true;
5571 llvm::outs() << StrTok.getStringContents() << '\n';
5572 return false;
5573}
5574
5575bool AsmParser::parseDirectiveAddrsig() {
5576 getStreamer().EmitAddrsig();
5577 return false;
5578}
5579
5580bool AsmParser::parseDirectiveAddrsigSym() {
5581 StringRef Name;
5582 if (check(parseIdentifier(Name),
5583 "expected identifier in '.addrsig_sym' directive"))
5584 return true;
5585 MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
5586 getStreamer().EmitAddrsigSym(Sym);
5587 return false;
5588}
5589
5590// We are comparing pointers, but the pointers are relative to a single string.
5591// Thus, this should always be deterministic.
5592static int rewritesSort(const AsmRewrite *AsmRewriteA,
5593 const AsmRewrite *AsmRewriteB) {
5594 if (AsmRewriteA->Loc.getPointer() < AsmRewriteB->Loc.getPointer())
5595 return -1;
5596 if (AsmRewriteB->Loc.getPointer() < AsmRewriteA->Loc.getPointer())
5597 return 1;
5598
5599 // It's possible to have a SizeDirective, Imm/ImmPrefix and an Input/Output
5600 // rewrite to the same location. Make sure the SizeDirective rewrite is
5601 // performed first, then the Imm/ImmPrefix and finally the Input/Output. This
5602 // ensures the sort algorithm is stable.
5603 if (AsmRewritePrecedence[AsmRewriteA->Kind] >
5604 AsmRewritePrecedence[AsmRewriteB->Kind])
5605 return -1;
5606
5607 if (AsmRewritePrecedence[AsmRewriteA->Kind] <
5608 AsmRewritePrecedence[AsmRewriteB->Kind])
5609 return 1;
5610 llvm_unreachable("Unstable rewrite sort.")::llvm::llvm_unreachable_internal("Unstable rewrite sort.", "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 5610)
;
5611}
5612
5613bool AsmParser::parseMSInlineAsm(
5614 void *AsmLoc, std::string &AsmString, unsigned &NumOutputs,
5615 unsigned &NumInputs, SmallVectorImpl<std::pair<void *, bool>> &OpDecls,
5616 SmallVectorImpl<std::string> &Constraints,
5617 SmallVectorImpl<std::string> &Clobbers, const MCInstrInfo *MII,
5618 const MCInstPrinter *IP, MCAsmParserSemaCallback &SI) {
5619 SmallVector<void *, 4> InputDecls;
5620 SmallVector<void *, 4> OutputDecls;
5621 SmallVector<bool, 4> InputDeclsAddressOf;
5622 SmallVector<bool, 4> OutputDeclsAddressOf;
5623 SmallVector<std::string, 4> InputConstraints;
5624 SmallVector<std::string, 4> OutputConstraints;
5625 SmallVector<unsigned, 4> ClobberRegs;
5626
5627 SmallVector<AsmRewrite, 4> AsmStrRewrites;
5628
5629 // Prime the lexer.
5630 Lex();
5631
5632 // While we have input, parse each statement.
5633 unsigned InputIdx = 0;
5634 unsigned OutputIdx = 0;
5635 while (getLexer().isNot(AsmToken::Eof)) {
5636 // Parse curly braces marking block start/end
5637 if (parseCurlyBlockScope(AsmStrRewrites))
5638 continue;
5639
5640 ParseStatementInfo Info(&AsmStrRewrites);
5641 bool StatementErr = parseStatement(Info, &SI);
5642
5643 if (StatementErr || Info.ParseError) {
5644 // Emit pending errors if any exist.
5645 printPendingErrors();
5646 return true;
5647 }
5648
5649 // No pending error should exist here.
5650 assert(!hasPendingError() && "unexpected error from parseStatement")((!hasPendingError() && "unexpected error from parseStatement"
) ? static_cast<void> (0) : __assert_fail ("!hasPendingError() && \"unexpected error from parseStatement\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 5650, __PRETTY_FUNCTION__))
;
5651
5652 if (Info.Opcode == ~0U)
5653 continue;
5654
5655 const MCInstrDesc &Desc = MII->get(Info.Opcode);
5656
5657 // Build the list of clobbers, outputs and inputs.
5658 for (unsigned i = 1, e = Info.ParsedOperands.size(); i != e; ++i) {
5659 MCParsedAsmOperand &Operand = *Info.ParsedOperands[i];
5660
5661 // Immediate.
5662 if (Operand.isImm())
5663 continue;
5664
5665 // Register operand.
5666 if (Operand.isReg() && !Operand.needAddressOf() &&
5667 !getTargetParser().OmitRegisterFromClobberLists(Operand.getReg())) {
5668 unsigned NumDefs = Desc.getNumDefs();
5669 // Clobber.
5670 if (NumDefs && Operand.getMCOperandNum() < NumDefs)
5671 ClobberRegs.push_back(Operand.getReg());
5672 continue;
5673 }
5674
5675 // Expr/Input or Output.
5676 StringRef SymName = Operand.getSymName();
5677 if (SymName.empty())
5678 continue;
5679
5680 void *OpDecl = Operand.getOpDecl();
5681 if (!OpDecl)
5682 continue;
5683
5684 bool isOutput = (i == 1) && Desc.mayStore();
5685 SMLoc Start = SMLoc::getFromPointer(SymName.data());
5686 if (isOutput) {
5687 ++InputIdx;
5688 OutputDecls.push_back(OpDecl);
5689 OutputDeclsAddressOf.push_back(Operand.needAddressOf());
5690 OutputConstraints.push_back(("=" + Operand.getConstraint()).str());
5691 AsmStrRewrites.emplace_back(AOK_Output, Start, SymName.size());
5692 } else {
5693 InputDecls.push_back(OpDecl);
5694 InputDeclsAddressOf.push_back(Operand.needAddressOf());
5695 InputConstraints.push_back(Operand.getConstraint().str());
5696 AsmStrRewrites.emplace_back(AOK_Input, Start, SymName.size());
5697 }
5698 }
5699
5700 // Consider implicit defs to be clobbers. Think of cpuid and push.
5701 ArrayRef<MCPhysReg> ImpDefs(Desc.getImplicitDefs(),
5702 Desc.getNumImplicitDefs());
5703 ClobberRegs.insert(ClobberRegs.end(), ImpDefs.begin(), ImpDefs.end());
5704 }
5705
5706 // Set the number of Outputs and Inputs.
5707 NumOutputs = OutputDecls.size();
5708 NumInputs = InputDecls.size();
5709
5710 // Set the unique clobbers.
5711 array_pod_sort(ClobberRegs.begin(), ClobberRegs.end());
5712 ClobberRegs.erase(std::unique(ClobberRegs.begin(), ClobberRegs.end()),
5713 ClobberRegs.end());
5714 Clobbers.assign(ClobberRegs.size(), std::string());
5715 for (unsigned I = 0, E = ClobberRegs.size(); I != E; ++I) {
5716 raw_string_ostream OS(Clobbers[I]);
5717 IP->printRegName(OS, ClobberRegs[I]);
5718 }
5719
5720 // Merge the various outputs and inputs. Output are expected first.
5721 if (NumOutputs || NumInputs) {
5722 unsigned NumExprs = NumOutputs + NumInputs;
5723 OpDecls.resize(NumExprs);
5724 Constraints.resize(NumExprs);
5725 for (unsigned i = 0; i < NumOutputs; ++i) {
5726 OpDecls[i] = std::make_pair(OutputDecls[i], OutputDeclsAddressOf[i]);
5727 Constraints[i] = OutputConstraints[i];
5728 }
5729 for (unsigned i = 0, j = NumOutputs; i < NumInputs; ++i, ++j) {
5730 OpDecls[j] = std::make_pair(InputDecls[i], InputDeclsAddressOf[i]);
5731 Constraints[j] = InputConstraints[i];
5732 }
5733 }
5734
5735 // Build the IR assembly string.
5736 std::string AsmStringIR;
5737 raw_string_ostream OS(AsmStringIR);
5738 StringRef ASMString =
5739 SrcMgr.getMemoryBuffer(SrcMgr.getMainFileID())->getBuffer();
5740 const char *AsmStart = ASMString.begin();
5741 const char *AsmEnd = ASMString.end();
5742 array_pod_sort(AsmStrRewrites.begin(), AsmStrRewrites.end(), rewritesSort);
5743 for (const AsmRewrite &AR : AsmStrRewrites) {
5744 AsmRewriteKind Kind = AR.Kind;
5745
5746 const char *Loc = AR.Loc.getPointer();
5747 assert(Loc >= AsmStart && "Expected Loc to be at or after Start!")((Loc >= AsmStart && "Expected Loc to be at or after Start!"
) ? static_cast<void> (0) : __assert_fail ("Loc >= AsmStart && \"Expected Loc to be at or after Start!\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 5747, __PRETTY_FUNCTION__))
;
5748
5749 // Emit everything up to the immediate/expression.
5750 if (unsigned Len = Loc - AsmStart)
5751 OS << StringRef(AsmStart, Len);
5752
5753 // Skip the original expression.
5754 if (Kind == AOK_Skip) {
5755 AsmStart = Loc + AR.Len;
5756 continue;
5757 }
5758
5759 unsigned AdditionalSkip = 0;
5760 // Rewrite expressions in $N notation.
5761 switch (Kind) {
5762 default:
5763 break;
5764 case AOK_IntelExpr:
5765 assert(AR.IntelExp.isValid() && "cannot write invalid intel expression")((AR.IntelExp.isValid() && "cannot write invalid intel expression"
) ? static_cast<void> (0) : __assert_fail ("AR.IntelExp.isValid() && \"cannot write invalid intel expression\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 5765, __PRETTY_FUNCTION__))
;
5766 if (AR.IntelExp.NeedBracs)
5767 OS << "[";
5768 if (AR.IntelExp.hasBaseReg())
5769 OS << AR.IntelExp.BaseReg;
5770 if (AR.IntelExp.hasIndexReg())
5771 OS << (AR.IntelExp.hasBaseReg() ? " + " : "")
5772 << AR.IntelExp.IndexReg;
5773 if (AR.IntelExp.Scale > 1)
5774 OS << " * $$" << AR.IntelExp.Scale;
5775 if (AR.IntelExp.Imm || !AR.IntelExp.hasRegs())
5776 OS << (AR.IntelExp.hasRegs() ? " + $$" : "$$") << AR.IntelExp.Imm;
5777 if (AR.IntelExp.NeedBracs)
5778 OS << "]";
5779 break;
5780 case AOK_Label:
5781 OS << Ctx.getAsmInfo()->getPrivateLabelPrefix() << AR.Label;
5782 break;
5783 case AOK_Input:
5784 OS << '$' << InputIdx++;
5785 break;
5786 case AOK_Output:
5787 OS << '$' << OutputIdx++;
5788 break;
5789 case AOK_SizeDirective:
5790 switch (AR.Val) {
5791 default: break;
5792 case 8: OS << "byte ptr "; break;
5793 case 16: OS << "word ptr "; break;
5794 case 32: OS << "dword ptr "; break;
5795 case 64: OS << "qword ptr "; break;
5796 case 80: OS << "xword ptr "; break;
5797 case 128: OS << "xmmword ptr "; break;
5798 case 256: OS << "ymmword ptr "; break;
5799 }
5800 break;
5801 case AOK_Emit:
5802 OS << ".byte";
5803 break;
5804 case AOK_Align: {
5805 // MS alignment directives are measured in bytes. If the native assembler
5806 // measures alignment in bytes, we can pass it straight through.
5807 OS << ".align";
5808 if (getContext().getAsmInfo()->getAlignmentIsInBytes())
5809 break;
5810
5811 // Alignment is in log2 form, so print that instead and skip the original
5812 // immediate.
5813 unsigned Val = AR.Val;
5814 OS << ' ' << Val;
5815 assert(Val < 10 && "Expected alignment less then 2^10.")((Val < 10 && "Expected alignment less then 2^10."
) ? static_cast<void> (0) : __assert_fail ("Val < 10 && \"Expected alignment less then 2^10.\""
, "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 5815, __PRETTY_FUNCTION__))
;
5816 AdditionalSkip = (Val < 4) ? 2 : Val < 7 ? 3 : 4;
5817 break;
5818 }
5819 case AOK_EVEN:
5820 OS << ".even";
5821 break;
5822 case AOK_EndOfStatement:
5823 OS << "\n\t";
5824 break;
5825 }
5826
5827 // Skip the original expression.
5828 AsmStart = Loc + AR.Len + AdditionalSkip;
5829 }
5830
5831 // Emit the remainder of the asm string.
5832 if (AsmStart != AsmEnd)
5833 OS << StringRef(AsmStart, AsmEnd - AsmStart);
5834
5835 AsmString = OS.str();
5836 return false;
5837}
5838
5839namespace llvm {
5840namespace MCParserUtils {
5841
5842/// Returns whether the given symbol is used anywhere in the given expression,
5843/// or subexpressions.
5844static bool isSymbolUsedInExpression(const MCSymbol *Sym, const MCExpr *Value) {
5845 switch (Value->getKind()) {
5846 case MCExpr::Binary: {
5847 const MCBinaryExpr *BE = static_cast<const MCBinaryExpr *>(Value);
5848 return isSymbolUsedInExpression(Sym, BE->getLHS()) ||
5849 isSymbolUsedInExpression(Sym, BE->getRHS());
5850 }
5851 case MCExpr::Target:
5852 case MCExpr::Constant:
5853 return false;
5854 case MCExpr::SymbolRef: {
5855 const MCSymbol &S =
5856 static_cast<const MCSymbolRefExpr *>(Value)->getSymbol();
5857 if (S.isVariable())
5858 return isSymbolUsedInExpression(Sym, S.getVariableValue());
5859 return &S == Sym;
5860 }
5861 case MCExpr::Unary:
5862 return isSymbolUsedInExpression(
5863 Sym, static_cast<const MCUnaryExpr *>(Value)->getSubExpr());
5864 }
5865
5866 llvm_unreachable("Unknown expr kind!")::llvm::llvm_unreachable_internal("Unknown expr kind!", "/build/llvm-toolchain-snapshot-8~svn349319/lib/MC/MCParser/AsmParser.cpp"
, 5866)
;
5867}
5868
5869bool parseAssignmentExpression(StringRef Name, bool allow_redef,
5870 MCAsmParser &Parser, MCSymbol *&Sym,
5871 const MCExpr *&Value) {
5872
5873 // FIXME: Use better location, we should use proper tokens.
5874 SMLoc EqualLoc = Parser.getTok().getLoc();
5875 if (Parser.parseExpression(Value))
5876 return Parser.TokError("missing expression");
5877
5878 // Note: we don't count b as used in "a = b". This is to allow
5879 // a = b
5880 // b = c
5881
5882 if (Parser.parseToken(AsmToken::EndOfStatement))
5883 return true;
5884
5885 // Validate that the LHS is allowed to be a variable (either it has not been
5886 // used as a symbol, or it is an absolute symbol).
5887 Sym = Parser.getContext().lookupSymbol(Name);
5888 if (Sym) {
5889 // Diagnose assignment to a label.
5890 //
5891 // FIXME: Diagnostics. Note the location of the definition as a label.
5892 // FIXME: Diagnose assignment to protected identifier (e.g., register name).
5893 if (isSymbolUsedInExpression(Sym, Value))
5894 return Parser.Error(EqualLoc, "Recursive use of '" + Name + "'");
5895 else if (Sym->isUndefined(/*SetUsed*/ false) && !Sym->isUsed() &&
5896 !Sym->isVariable())
5897 ; // Allow redefinitions of undefined symbols only used in directives.
5898 else if (Sym->isVariable() && !Sym->isUsed() && allow_redef)
5899 ; // Allow redefinitions of variables that haven't yet been used.
5900 else if (!Sym->isUndefined() && (!Sym->isVariable() || !allow_redef))
5901 return Parser.Error(EqualLoc, "redefinition of '" + Name + "'");
5902 else if (!Sym->isVariable())
5903 return Parser.Error(EqualLoc, "invalid assignment to '" + Name + "'");
5904 else if (!isa<MCConstantExpr>(Sym->getVariableValue()))
5905 return Parser.Error(EqualLoc,
5906 "invalid reassignment of non-absolute variable '" +
5907 Name + "'");
5908 } else if (Name == ".") {
5909 Parser.getStreamer().emitValueToOffset(Value, 0, EqualLoc);
5910 return false;
5911 } else
5912 Sym = Parser.getContext().getOrCreateSymbol(Name);
5913
5914 Sym->setRedefinable(allow_redef);
5915
5916 return false;
5917}
5918
5919} // end namespace MCParserUtils
5920} // end namespace llvm
5921
5922/// Create an MCAsmParser instance.
5923MCAsmParser *llvm::createMCAsmParser(SourceMgr &SM, MCContext &C,
5924 MCStreamer &Out, const MCAsmInfo &MAI,
5925 unsigned CB) {
5926 return new AsmParser(SM, C, Out, MAI, CB);
5927}