|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
include/llvm/MC/MCContext.h 59 class SMLoc;
include/llvm/MC/MCDwarf.h 41 class SMLoc;
lib/TableGen/TGLexer.h 28 class SMLoc;
References
gen/lib/Target/ARM/ARMGenAsmMatcher.inc15304 SMLoc Loc = ((ARMOperand&)*Operands[0]).getStartLoc();
gen/lib/Target/PowerPC/PPCGenAsmMatcher.inc 7186 SMLoc Loc = ((PPCOperand&)*Operands[0]).getStartLoc();
include/llvm/ADT/ArrayRef.h 43 using iterator = const T *;
44 using const_iterator = const T *;
50 const T *Data = nullptr;
66 /*implicit*/ ArrayRef(const T &OneElt)
70 /*implicit*/ ArrayRef(const T *data, size_t length)
74 ArrayRef(const T *begin, const T *end)
74 ArrayRef(const T *begin, const T *end)
81 /*implicit*/ ArrayRef(const SmallVectorTemplateCommon<T, U> &Vec)
87 /*implicit*/ ArrayRef(const std::vector<T, A> &Vec)
92 /*implicit*/ constexpr ArrayRef(const std::array<T, N> &Arr)
97 /*implicit*/ constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {}
100 /*implicit*/ ArrayRef(const std::initializer_list<T> &Vec)
145 const T *data() const { return Data; }
151 const T &front() const {
157 const T &back() const {
163 template <typename Allocator> ArrayRef<T> copy(Allocator &A) {
178 ArrayRef<T> slice(size_t N, size_t M) const {
184 ArrayRef<T> slice(size_t N) const { return slice(N, size() - N); }
187 ArrayRef<T> drop_front(size_t N = 1) const {
193 ArrayRef<T> drop_back(size_t N = 1) const {
200 template <class PredicateT> ArrayRef<T> drop_while(PredicateT Pred) const {
206 template <class PredicateT> ArrayRef<T> drop_until(PredicateT Pred) const {
211 ArrayRef<T> take_front(size_t N = 1) const {
218 ArrayRef<T> take_back(size_t N = 1) const {
226 template <class PredicateT> ArrayRef<T> take_while(PredicateT Pred) const {
232 template <class PredicateT> ArrayRef<T> take_until(PredicateT Pred) const {
239 const T &operator[](size_t Index) const {
249 typename std::enable_if<std::is_same<U, T>::value, ArrayRef<T>>::type &
257 typename std::enable_if<std::is_same<U, T>::value, ArrayRef<T>>::type &
263 std::vector<T> vec() const {
270 operator std::vector<T>() const {
include/llvm/ADT/SmallVector.h 75 AlignedCharArrayUnion<T> FirstEl;
114 using value_type = T;
115 using iterator = T *;
116 using const_iterator = const T *;
121 using reference = T &;
122 using const_reference = const T &;
123 using pointer = T *;
124 using const_pointer = const T *;
259 class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
264 static void destroy_range(T *, T *) {}
264 static void destroy_range(T *, T *) {}
286 T1 *I, T1 *E, T2 *Dest,
286 T1 *I, T1 *E, T2 *Dest,
286 T1 *I, T1 *E, T2 *Dest,
287 typename std::enable_if<std::is_same<typename std::remove_const<T1>::type,
288 T2>::value>::type * = nullptr) {
294 memcpy(reinterpret_cast<void *>(Dest), I, (E - I) * sizeof(T));
299 void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); }
302 void push_back(const T &Elt) {
305 memcpy(reinterpret_cast<void *>(this->end()), &Elt, sizeof(T));
315 class SmallVectorImpl : public SmallVectorTemplateBase<T> {
316 using SuperClass = SmallVectorTemplateBase<T>;
352 new (&*I) T();
357 void resize(size_type N, const T &NV) {
374 LLVM_NODISCARD T pop_back_val() {
397 void append(size_type NumInputs, const T &Elt) {
405 void append(std::initializer_list<T> IL) {
412 void assign(size_type NumElts, const T &Elt) {
429 void assign(std::initializer_list<T> IL) {
467 iterator insert(iterator I, T &&Elt) {
497 iterator insert(iterator I, const T &Elt) {
526 iterator insert(iterator I, size_type NumToInsert, const T &Elt) {
637 void insert(iterator I, std::initializer_list<T> IL) {
641 template <typename... ArgTypes> reference emplace_back(ArgTypes &&... Args) {
644 ::new ((void *)this->end()) T(std::forward<ArgTypes>(Args)...);
820 AlignedCharArrayUnion<T> InlineElts[N];
837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
846 explicit SmallVector(size_t Size, const T &Value = T())
865 SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
884 SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {
include/llvm/MC/ConstantPools.h 33 ConstantPoolEntry(MCSymbol *L, const MCExpr *Val, unsigned Sz, SMLoc Loc_)
39 SMLoc Loc;
59 unsigned Size, SMLoc Loc);
93 unsigned Size, SMLoc Loc);
include/llvm/MC/MCAsmMacro.h 85 SMLoc getLoc() const;
86 SMLoc getEndLoc() const;
include/llvm/MC/MCContext.h 681 void reportError(SMLoc L, const Twine &Msg);
682 void reportWarning(SMLoc L, const Twine &Msg);
686 LLVM_ATTRIBUTE_NORETURN void reportFatalError(SMLoc L,
include/llvm/MC/MCDwarf.h 432 SMLoc &Loc);
include/llvm/MC/MCELFStreamer.h 43 void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
44 void EmitLabel(MCSymbol *Symbol, SMLoc Loc, MCFragment *F) override;
62 SMLoc L = SMLoc()) override;
66 SMLoc Loc = SMLoc()) override;
include/llvm/MC/MCExpr.h 47 SMLoc Loc;
54 explicit MCExpr(ExprKind Kind, SMLoc Loc) : Kind(Kind), Loc(Loc) {}
69 SMLoc getLoc() const { return Loc; }
323 const MCAsmInfo *MAI, SMLoc Loc = SMLoc());
334 MCContext &Ctx, SMLoc Loc = SMLoc());
379 MCUnaryExpr(Opcode Op, const MCExpr *Expr, SMLoc Loc)
387 MCContext &Ctx, SMLoc Loc = SMLoc());
389 static const MCUnaryExpr *createLNot(const MCExpr *Expr, MCContext &Ctx, SMLoc Loc = SMLoc()) {
393 static const MCUnaryExpr *createMinus(const MCExpr *Expr, MCContext &Ctx, SMLoc Loc = SMLoc()) {
397 static const MCUnaryExpr *createNot(const MCExpr *Expr, MCContext &Ctx, SMLoc Loc = SMLoc()) {
401 static const MCUnaryExpr *createPlus(const MCExpr *Expr, MCContext &Ctx, SMLoc Loc = SMLoc()) {
456 SMLoc Loc = SMLoc())
465 SMLoc Loc = SMLoc());
include/llvm/MC/MCFixup.h 91 SMLoc Loc;
94 MCFixupKind Kind, SMLoc Loc = SMLoc()) {
197 SMLoc getLoc() const { return Loc; }
include/llvm/MC/MCFragment.h 437 SMLoc Loc;
441 SMLoc Loc, MCSection *Sec = nullptr)
449 SMLoc getLoc() const { return Loc; }
464 SMLoc Loc;
467 MCOrgFragment(const MCExpr &Offset, int8_t Value, SMLoc Loc,
478 SMLoc getLoc() const { return Loc; }
include/llvm/MC/MCInst.h 160 SMLoc Loc;
176 void setLoc(SMLoc loc) { Loc = loc; }
177 SMLoc getLoc() const { return Loc; }
include/llvm/MC/MCObjectStreamer.h 109 void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
110 virtual void EmitLabel(MCSymbol *Symbol, SMLoc Loc, MCFragment *F);
113 SMLoc Loc = SMLoc()) override;
134 SMLoc Loc) override;
150 StringRef FileName, SMLoc Loc) override;
171 const MCExpr *Expr, SMLoc Loc,
175 SMLoc Loc = SMLoc()) override;
177 SMLoc Loc = SMLoc()) override;
include/llvm/MC/MCParser/MCAsmLexer.h 33 virtual void HandleComment(SMLoc Loc, StringRef CommentText) = 0;
44 SMLoc ErrLoc;
59 void SetError(SMLoc errLoc, const std::string &err) {
97 SMLoc getLoc() const;
122 SMLoc getErrLoc() {
include/llvm/MC/MCParser/MCAsmParser.h 102 SMLoc Location, bool Create) = 0;
111 using DirectiveHandler = bool (*)(MCAsmParserExtension*, StringRef, SMLoc);
116 SMLoc Loc;
180 virtual void Note(SMLoc L, const Twine &Msg, SMRange Range = None) = 0;
185 virtual bool Warning(SMLoc L, const Twine &Msg, SMRange Range = None) = 0;
192 bool Error(SMLoc L, const Twine &Msg, SMRange Range = None);
198 virtual bool printError(SMLoc L, const Twine &Msg, SMRange Range = None) = 0;
225 bool parseTokenLoc(SMLoc &Loc);
238 bool check(bool P, SMLoc Loc, const Twine &Msg);
261 virtual bool parseExpression(const MCExpr *&Res, SMLoc &EndLoc) = 0;
269 virtual bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) = 0;
277 virtual bool parseParenExpression(const MCExpr *&Res, SMLoc &EndLoc) = 0;
300 SMLoc &EndLoc) = 0;
include/llvm/MC/MCParser/MCAsmParserExtension.h 35 SMLoc DirectiveLoc) {
70 bool Warning(SMLoc L, const Twine &Msg) {
74 bool Error(SMLoc L, const Twine &Msg, SMRange Range = SMRange()) {
78 void Note(SMLoc L, const Twine &Msg) {
105 bool check(bool P, SMLoc Loc, const Twine &Msg) {
include/llvm/MC/MCParser/MCParsedAsmOperand.h 66 virtual SMLoc getStartLoc() const = 0;
68 virtual SMLoc getEndLoc() const = 0;
80 virtual SMLoc getOffsetOfLoc() const { return SMLoc(); }
include/llvm/MC/MCParser/MCTargetAsmParser.h 108 SMLoc Loc;
115 AsmRewrite(AsmRewriteKind kind, SMLoc loc, unsigned len = 0, int64_t val = 0)
117 AsmRewrite(AsmRewriteKind kind, SMLoc loc, unsigned len, StringRef label)
119 AsmRewrite(SMLoc loc, unsigned len, IntelExpr exp)
380 virtual bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) {
384 virtual bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
385 SMLoc &EndLoc) = 0;
401 SMLoc NameLoc, OperandVector &Operands) = 0;
425 virtual bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
include/llvm/MC/MCStreamer.h 176 const MCExpr *addConstantPoolEntry(const MCExpr *, SMLoc Loc);
240 bool checkCVLocSection(unsigned FuncId, unsigned FileNo, SMLoc Loc);
275 WinEH::FrameInfo *EnsureValidWinFrameInfo(SMLoc Loc);
445 virtual void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc());
601 SMLoc Loc = SMLoc()) = 0;
638 SMLoc Loc = SMLoc());
640 void EmitValue(const MCExpr *Value, unsigned Size, SMLoc Loc = SMLoc());
724 SMLoc Loc = SMLoc());
735 SMLoc Loc = SMLoc());
784 SMLoc Loc);
853 unsigned IACol, SMLoc Loc);
859 StringRef FileName, SMLoc Loc);
907 virtual void EmitCVFPOData(const MCSymbol *ProcSym, SMLoc Loc = {}) {}
921 void EmitCFIStartProc(bool IsSimple, SMLoc Loc = SMLoc());
944 virtual void EmitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc = SMLoc());
945 virtual void EmitWinCFIEndProc(SMLoc Loc = SMLoc());
950 virtual void EmitWinCFIFuncletOrFuncEnd(SMLoc Loc = SMLoc());
951 virtual void EmitWinCFIStartChained(SMLoc Loc = SMLoc());
952 virtual void EmitWinCFIEndChained(SMLoc Loc = SMLoc());
953 virtual void EmitWinCFIPushReg(MCRegister Register, SMLoc Loc = SMLoc());
955 SMLoc Loc = SMLoc());
956 virtual void EmitWinCFIAllocStack(unsigned Size, SMLoc Loc = SMLoc());
958 SMLoc Loc = SMLoc());
960 SMLoc Loc = SMLoc());
961 virtual void EmitWinCFIPushFrame(bool Code, SMLoc Loc = SMLoc());
962 virtual void EmitWinCFIEndProlog(SMLoc Loc = SMLoc());
964 SMLoc Loc = SMLoc());
965 virtual void EmitWinEHHandlerData(SMLoc Loc = SMLoc());
984 const MCExpr *Expr, SMLoc Loc,
include/llvm/MC/MCWasmStreamer.h 63 SMLoc Loc = SMLoc()) override;
67 SMLoc Loc = SMLoc()) override;
include/llvm/MC/MCWinCOFFStreamer.h 43 void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
62 unsigned ByteAlignment, SMLoc Loc = SMLoc()) override;
66 void EmitWinEHHandlerData(SMLoc Loc) override;
include/llvm/MC/MCXCOFFStreamer.h 27 SMLoc Loc = SMLoc()) override;
include/llvm/Support/AlignOf.h 30 T t;
39 template <typename T> union SizerImpl<T> { char arr[sizeof(T)]; };
50 llvm::detail::SizerImpl<T, Ts...>)];
include/llvm/Support/FileCheck.h 131 SMLoc CheckLoc, MatchType MatchTy, SMRange InputRange);
include/llvm/Support/SMLoc.h 31 bool operator==(const SMLoc &RHS) const { return RHS.Ptr == Ptr; }
32 bool operator!=(const SMLoc &RHS) const { return RHS.Ptr != Ptr; }
36 static SMLoc getFromPointer(const char *Ptr) {
37 SMLoc L;
50 SMLoc Start, End;
54 SMRange(SMLoc St, SMLoc En) : Start(St), End(En) {
54 SMRange(SMLoc St, SMLoc En) : Start(St), End(En) {
include/llvm/Support/SourceMgr.h 85 SMLoc IncludeLoc;
146 SMLoc getParentIncludeLoc(unsigned i) const {
154 SMLoc IncludeLoc) {
168 unsigned AddIncludeFile(const std::string &Filename, SMLoc IncludeLoc,
174 unsigned FindBufferContainingLoc(SMLoc Loc) const;
178 unsigned FindLineNumber(SMLoc Loc, unsigned BufferID = 0) const {
184 std::pair<unsigned, unsigned> getLineAndColumn(SMLoc Loc,
191 void PrintMessage(raw_ostream &OS, SMLoc Loc, DiagKind Kind,
198 void PrintMessage(SMLoc Loc, DiagKind Kind, const Twine &Msg,
215 SMDiagnostic GetMessage(SMLoc Loc, DiagKind Kind, const Twine &Msg,
225 void PrintIncludeStack(SMLoc IncludeLoc, raw_ostream &OS) const;
236 SMFixIt(SMLoc Loc, const Twine &Insertion)
263 SMLoc Loc;
280 SMDiagnostic(const SourceMgr &sm, SMLoc L, StringRef FN,
287 SMLoc getLoc() const { return Loc; }
include/llvm/Support/YAMLParser.h 213 SMLoc Start = SMLoc::getFromPointer(Val.begin());
213 SMLoc Start = SMLoc::getFromPointer(Val.begin());
214 SMLoc End = SMLoc::getFromPointer(Val.end());
214 SMLoc End = SMLoc::getFromPointer(Val.end());
256 SMLoc Start = SMLoc::getFromPointer(RawVal.begin());
256 SMLoc Start = SMLoc::getFromPointer(RawVal.begin());
257 SMLoc End = SMLoc::getFromPointer(RawVal.end());
257 SMLoc End = SMLoc::getFromPointer(RawVal.end());
include/llvm/Support/type_traits.h 91 T t;
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
145 std::is_copy_constructible<detail::trivial_helper<T>>::value;
147 !std::is_copy_constructible<T>::value;
151 std::is_move_constructible<detail::trivial_helper<T>>::value;
153 !std::is_move_constructible<T>::value;
157 is_copy_assignable<detail::trivial_helper<T>>::value;
159 !is_copy_assignable<T>::value;
163 is_move_assignable<detail::trivial_helper<T>>::value;
165 !is_move_assignable<T>::value;
169 std::is_destructible<detail::trivial_helper<T>>::value;
include/llvm/TableGen/Error.h 22 void PrintNote(ArrayRef<SMLoc> NoteLoc, const Twine &Msg);
24 void PrintWarning(ArrayRef<SMLoc> WarningLoc, const Twine &Msg);
28 void PrintError(ArrayRef<SMLoc> ErrorLoc, const Twine &Msg);
33 LLVM_ATTRIBUTE_NORETURN void PrintFatalError(ArrayRef<SMLoc> ErrorLoc,
include/llvm/TableGen/Record.h 626 SMLoc Loc;
628 explicit CodeInit(StringRef V, const SMLoc &Loc)
640 static CodeInit *get(StringRef, const SMLoc &Loc);
643 const SMLoc &getLoc() const { return Loc; }
1333 Record *getOperatorAsDef(ArrayRef<SMLoc> Loc) const;
1433 SmallVector<SMLoc, 4> Locs;
1456 explicit Record(Init *N, ArrayRef<SMLoc> locs, RecordKeeper &records,
1463 explicit Record(StringRef N, ArrayRef<SMLoc> locs, RecordKeeper &records,
1492 ArrayRef<SMLoc> getLoc() const { return Locs; }
1493 void appendLoc(SMLoc Loc) { Locs.push_back(Loc); }
include/llvm/TableGen/SetTheory.h 79 ArrayRef<SMLoc> Loc) = 0;
127 void evaluate(Init *Expr, RecSet &Elts, ArrayRef<SMLoc> Loc);
131 void evaluate(Iter begin, Iter end, RecSet &Elts, ArrayRef<SMLoc> Loc) {
lib/AsmParser/LLLexer.h 56 typedef SMLoc LocTy;
57 LocTy getLoc() const { return SMLoc::getFromPointer(TokStart); }
lib/AsmParser/LLParser.cpp 96 SMLoc Start = Lex.getLoc();
100 SMLoc End = Lex.getLoc();
2175 auto StartParen = Lex.getLoc();
2183 auto HowManyAt = Lex.getLoc();
2194 auto EndParen = Lex.getLoc();
2220 auto StartParenAt = Lex.getLoc();
2225 auto SSNAt = Lex.getLoc();
2229 auto EndParenAt = Lex.getLoc();
2317 SMLoc TypeLoc = Lex.getLoc();
2683 bool LLParser::ParseStructDefinition(SMLoc TypeLoc, StringRef Name,
4676 auto Loc = Lex.getLoc();
5250 auto Loc = Lex.getLoc();
5895 SMLoc TypeLoc = Lex.getLoc();
7323 SMLoc Loc) {
7349 SMLoc Loc = Lex.getLoc();
7391 SMLoc Loc = Lex.getLoc();
7409 SMLoc Loc = Lex.getLoc();
lib/AsmParser/LLParser.h 110 SMLoc Loc;
405 bool ParseStructDefinition(SMLoc TypeLoc, StringRef Name,
608 bool sortUseListOrder(Value *V, ArrayRef<unsigned> Indexes, SMLoc Loc);
lib/AsmParser/Parser.cpp 169 Err = SM.GetMessage(SMLoc::getFromPointer(Asm.begin() + Read),
lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp 545 SMLoc Loc = SMLoc::getFromPointer(
545 SMLoc Loc = SMLoc::getFromPointer(
lib/CodeGen/MIRParser/MIParser.cpp 543 Error = SM.GetMessage(SMLoc::getFromPointer(Loc), SourceMgr::DK_Error, Msg);
lib/CodeGen/MIRParser/MIRParser.cpp 81 bool error(SMLoc Loc, const Twine &Message);
182 bool MIRParserImpl::error(SMLoc Loc, const Twine &Message) {
871 SMLoc Loc = SourceRange.Start;
894 SMLoc Loc = Error.getLoc();
902 Loc = SMLoc::getFromPointer(LineStr.data());
lib/MC/ConstantPools.cpp 40 unsigned Size, SMLoc Loc) {
111 unsigned Size, SMLoc Loc) {
lib/MC/ELFObjectWriter.cpp 264 virtual bool checkRelocation(MCContext &Ctx, SMLoc Loc,
314 virtual bool checkRelocation(MCContext &Ctx, SMLoc Loc,
lib/MC/MCAsmStreamer.cpp 142 void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
183 SMLoc Loc = SMLoc()) override;
193 SMLoc Loc = SMLoc()) override;
211 SMLoc Loc = SMLoc()) override;
214 SMLoc Loc = SMLoc()) override;
225 SMLoc Loc) override;
250 unsigned IACol, SMLoc Loc) override;
253 StringRef FileName, SMLoc Loc) override;
284 void EmitCVFPOData(const MCSymbol *ProcSym, SMLoc L) override;
310 void EmitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc) override;
311 void EmitWinCFIEndProc(SMLoc Loc) override;
312 void EmitWinCFIFuncletOrFuncEnd(SMLoc Loc) override;
313 void EmitWinCFIStartChained(SMLoc Loc) override;
314 void EmitWinCFIEndChained(SMLoc Loc) override;
315 void EmitWinCFIPushReg(MCRegister Register, SMLoc Loc) override;
317 SMLoc Loc) override;
318 void EmitWinCFIAllocStack(unsigned Size, SMLoc Loc) override;
320 SMLoc Loc) override;
322 SMLoc Loc) override;
323 void EmitWinCFIPushFrame(bool Code, SMLoc Loc) override;
324 void EmitWinCFIEndProlog(SMLoc Loc) override;
327 SMLoc Loc) override;
328 void EmitWinEHHandlerData(SMLoc Loc) override;
340 const MCExpr *Expr, SMLoc Loc,
463 void MCAsmStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
831 SMLoc Loc) {
972 SMLoc Loc) {
1094 SMLoc Loc) {
1113 int64_t Expr, SMLoc Loc) {
1193 SMLoc Loc) {
1372 SMLoc Loc) {
1382 StringRef FileName, SMLoc Loc) {
1492 void MCAsmStreamer::EmitCVFPOData(const MCSymbol *ProcSym, SMLoc L) {
1698 void MCAsmStreamer::EmitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc) {
1706 void MCAsmStreamer::EmitWinCFIEndProc(SMLoc Loc) {
1714 void MCAsmStreamer::EmitWinCFIFuncletOrFuncEnd(SMLoc Loc) {
1717 void MCAsmStreamer::EmitWinCFIStartChained(SMLoc Loc) {
1724 void MCAsmStreamer::EmitWinCFIEndChained(SMLoc Loc) {
1732 bool Except, SMLoc Loc) {
1744 void MCAsmStreamer::EmitWinEHHandlerData(SMLoc Loc) {
1766 void MCAsmStreamer::EmitWinCFIPushReg(MCRegister Register, SMLoc Loc) {
1775 SMLoc Loc) {
1784 void MCAsmStreamer::EmitWinCFIAllocStack(unsigned Size, SMLoc Loc) {
1792 SMLoc Loc) {
1802 SMLoc Loc) {
1811 void MCAsmStreamer::EmitWinCFIPushFrame(bool Code, SMLoc Loc) {
1820 void MCAsmStreamer::EmitWinCFIEndProlog(SMLoc Loc) {
1973 const MCExpr *Expr, SMLoc,
lib/MC/MCContext.cpp 687 void MCContext::reportError(SMLoc Loc, const Twine &Msg) {
701 void MCContext::reportWarning(SMLoc Loc, const Twine &Msg) {
716 void MCContext::reportFatalError(SMLoc Loc, const Twine &Msg) {
lib/MC/MCDwarf.cpp 1208 SourceMgr &SrcMgr, SMLoc &Loc) {
lib/MC/MCELFStreamer.cpp 99 void MCELFStreamer::EmitLabel(MCSymbol *S, SMLoc Loc) {
109 void MCELFStreamer::EmitLabel(MCSymbol *S, SMLoc Loc, MCFragment *F) {
345 SMLoc Loc) {
692 SMLoc Loc) {
lib/MC/MCExpr.cpp 160 SMLoc Loc) {
165 MCContext &Ctx, SMLoc Loc) {
177 const MCAsmInfo *MAI, SMLoc Loc)
187 MCContext &Ctx, SMLoc Loc) {
lib/MC/MCMachOStreamer.cpp 85 void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
105 SMLoc Loc = SMLoc()) override;
181 void MCMachOStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
424 SMLoc Loc) {
lib/MC/MCNullStreamer.cpp 37 SMLoc Loc = SMLoc()) override {}
lib/MC/MCObjectStreamer.cpp 191 SMLoc Loc) {
232 void MCObjectStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
250 void MCObjectStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc, MCFragment *F) {
465 StringRef FileName, SMLoc Loc) {
553 SMLoc Loc) {
628 const MCExpr *Expr, SMLoc Loc,
667 SMLoc Loc) {
676 int64_t Expr, SMLoc Loc) {
lib/MC/MCParser/AsmLexer.cpp 53 SetError(SMLoc::getFromPointer(Loc), Msg);
192 SMLoc::getFromPointer(CommentTextStart),
220 SMLoc::getFromPointer(CommentTextStart),
517 SMLoc SavedErrLoc = getErrLoc();
lib/MC/MCParser/AsmParser.cpp 91 SMLoc InstantiationLoc;
97 SMLoc ExitLoc;
103 MacroInstantiation(SMLoc IL, int EB, SMLoc EL, size_t CondStackDepth);
103 MacroInstantiation(SMLoc IL, int EB, SMLoc EL, size_t CondStackDepth);
163 SMLoc Loc;
173 SmallVector<std::tuple<SMLoc, CppHashInfoTy, MCSymbol *>, 4> DirLabels;
228 void Note(SMLoc L, const Twine &Msg, SMRange Range = None) override;
229 bool Warning(SMLoc L, const Twine &Msg, SMRange Range = None) override;
230 bool printError(SMLoc L, const Twine &Msg, SMRange Range = None) override;
251 bool parseExpression(const MCExpr *&Res, SMLoc &EndLoc) override;
252 bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) override;
253 bool parseParenExpression(const MCExpr *&Res, SMLoc &EndLoc) override;
255 SMLoc &EndLoc) override;
275 bool parseCppHashLineFilenameComment(SMLoc L);
277 void checkForBadMacro(SMLoc DirectiveLoc, StringRef Name, StringRef Body,
282 SMLoc L);
297 bool handleMacroEntry(const MCAsmMacro *M, SMLoc NameLoc);
309 void printMessage(SMLoc Loc, SourceMgr::DiagKind Kind, const Twine &Msg,
327 const MCExpr *Count = nullptr, SMLoc Loc = SMLoc());
335 void jumpToLoc(SMLoc Loc, unsigned InBuffer = 0);
352 bool parseBinOpRHS(unsigned Precedence, const MCExpr *&Res, SMLoc &EndLoc);
353 bool parseParenExpr(const MCExpr *&Res, SMLoc &EndLoc);
354 bool parseBracketExpr(const MCExpr *&Res, SMLoc &EndLoc);
356 bool parseRegisterOrRegisterNumber(int64_t &Register, SMLoc DirectiveLoc);
543 bool parseDirectiveReloc(SMLoc DirectiveLoc); // ".reloc"
558 bool parseDirectiveFile(SMLoc DirectiveLoc);
579 bool parseDirectiveCFIRegister(SMLoc DirectiveLoc);
585 bool parseDirectiveCFIDefCfa(SMLoc DirectiveLoc);
587 bool parseDirectiveCFIDefCfaRegister(SMLoc DirectiveLoc);
588 bool parseDirectiveCFIOffset(SMLoc DirectiveLoc);
589 bool parseDirectiveCFIRelOffset(SMLoc DirectiveLoc);
593 bool parseDirectiveCFISameValue(SMLoc DirectiveLoc);
594 bool parseDirectiveCFIRestore(SMLoc DirectiveLoc);
596 bool parseDirectiveCFIReturnColumn(SMLoc DirectiveLoc);
598 bool parseDirectiveCFIUndefined(SMLoc DirectiveLoc);
601 bool parseDirectivePurgeMacro(SMLoc DirectiveLoc);
604 bool parseDirectiveMacro(SMLoc DirectiveLoc);
638 bool parseDirectiveIf(SMLoc DirectiveLoc, DirectiveKind DirKind);
640 bool parseDirectiveIfb(SMLoc DirectiveLoc, bool ExpectBlank);
642 bool parseDirectiveIfc(SMLoc DirectiveLoc, bool ExpectEqual);
644 bool parseDirectiveIfeqs(SMLoc DirectiveLoc, bool ExpectEqual);
646 bool parseDirectiveIfdef(SMLoc DirectiveLoc, bool expect_defined);
647 bool parseDirectiveElseIf(SMLoc DirectiveLoc); // ".elseif"
648 bool parseDirectiveElse(SMLoc DirectiveLoc); // ".else"
649 bool parseDirectiveEndIf(SMLoc DirectiveLoc); // .endif
656 MCAsmMacro *parseMacroLikeBody(SMLoc DirectiveLoc);
657 void instantiateMacroLikeBody(MCAsmMacro *M, SMLoc DirectiveLoc,
659 bool parseDirectiveRept(SMLoc DirectiveLoc, StringRef Directive);
660 bool parseDirectiveIrp(SMLoc DirectiveLoc); // ".irp"
661 bool parseDirectiveIrpc(SMLoc DirectiveLoc); // ".irpc"
662 bool parseDirectiveEndr(SMLoc DirectiveLoc); // ".endr"
665 bool parseDirectiveMSEmit(SMLoc DirectiveLoc, ParseStatementInfo &Info,
669 bool parseDirectiveMSAlign(SMLoc DirectiveLoc, ParseStatementInfo &Info);
672 bool parseDirectiveEnd(SMLoc DirectiveLoc);
675 bool parseDirectiveError(SMLoc DirectiveLoc, bool WithMessage);
678 bool parseDirectiveWarning(SMLoc DirectiveLoc);
681 bool parseDirectivePrint(SMLoc DirectiveLoc);
763 void AsmParser::Note(SMLoc L, const Twine &Msg, SMRange Range) {
769 bool AsmParser::Warning(SMLoc L, const Twine &Msg, SMRange Range) {
779 bool AsmParser::printError(SMLoc L, const Twine &Msg, SMRange Range) {
802 const MCExpr *Count, SMLoc Loc) {
824 void AsmParser::jumpToLoc(SMLoc Loc, unsigned InBuffer) {
854 SMLoc ParentIncludeLoc = SrcMgr.getParentIncludeLoc(CurBuffer);
982 for (std::tuple<SMLoc, CppHashInfoTy, MCSymbol *> &LocSym : DirLabels) {
1045 bool AsmParser::parseParenExpr(const MCExpr *&Res, SMLoc &EndLoc) {
1060 bool AsmParser::parseBracketExpr(const MCExpr *&Res, SMLoc &EndLoc) {
1075 bool AsmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) {
1076 SMLoc FirstTokenLoc = getLexer().getLoc();
1118 SMLoc AtLoc = getLexer().getLoc();
1139 EndLoc = SMLoc::getFromPointer(Identifier.end());
1156 return Error(SMLoc::getFromPointer(Split.second.begin()),
1187 SMLoc Loc = getTok().getLoc();
1302 SMLoc EndLoc;
1371 static bool isAltmacroString(SMLoc &StrLoc, SMLoc &EndLoc) {
1371 static bool isAltmacroString(SMLoc &StrLoc, SMLoc &EndLoc) {
1409 bool AsmParser::parseExpression(const MCExpr *&Res, SMLoc &EndLoc) {
1449 bool AsmParser::parseParenExpression(const MCExpr *&Res, SMLoc &EndLoc) {
1455 SMLoc &EndLoc) {
1478 SMLoc StartLoc = Lexer.getLoc();
1652 SMLoc &EndLoc) {
1653 SMLoc StartLoc = Lexer.getLoc();
1702 SMLoc IDLoc = ID.getLoc();
1908 SMLoc StartTokLoc = getTok().getLoc();
2288 SMLoc StartLoc = Lexer.getLoc();
2301 bool AsmParser::parseCppHashLineFilenameComment(SMLoc L) {
2335 SMLoc DiagLoc = Diag.getLoc();
2345 SMLoc ParentIncludeLoc = DiagSrcMgr.getParentIncludeLoc(DiagCurBuffer);
2394 bool EnableAtPseudoVariable, SMLoc L) {
2523 MacroInstantiation::MacroInstantiation(SMLoc IL, int EB, SMLoc EL,
2523 MacroInstantiation::MacroInstantiation(SMLoc IL, int EB, SMLoc EL,
2653 SmallVector<SMLoc, 4> FALocs;
2664 SMLoc IDLoc = Lexer.getLoc();
2683 SMLoc StrLoc = Lexer.getLoc();
2684 SMLoc EndLoc;
2767 bool AsmParser::handleMacroEntry(const MCAsmMacro *M, SMLoc NameLoc) {
2859 SMLoc PrefixLoc = getLexer().getLoc();
3000 bool AsmParser::parseDirectiveReloc(SMLoc DirectiveLoc) {
3004 SMLoc OffsetLoc = Lexer.getTok().getLoc();
3019 SMLoc NameLoc = Lexer.getTok().getLoc();
3025 SMLoc ExprLoc = Lexer.getLoc();
3051 SMLoc ExprLoc = getLexer().getLoc();
3075 SMLoc ExprLoc = Asm.getTok().getLoc();
3176 SMLoc NumBytesLoc = Lexer.getLoc();
3199 SMLoc NumValuesLoc = Lexer.getLoc();
3207 SMLoc SizeLoc, ExprLoc;
3244 SMLoc OffsetLoc = Lexer.getLoc();
3263 SMLoc AlignmentLoc = getLexer().getLoc();
3265 SMLoc MaxBytesLoc;
3358 bool AsmParser::parseDirectiveFile(SMLoc DirectiveLoc) {
3500 SMLoc Loc = getTok().getLoc();
3530 SMLoc Loc = getTok().getLoc();
3598 SMLoc FileNumberLoc = getTok().getLoc();
3637 SMLoc Loc;
3646 SMLoc Loc;
3661 SMLoc FunctionIdLoc = getTok().getLoc();
3684 SMLoc FunctionIdLoc = getTok().getLoc();
3744 SMLoc DirectiveLoc = getTok().getLoc();
3771 SMLoc Loc = getTok().getLoc();
3808 SMLoc Loc = getTok().getLoc();
3832 SMLoc Loc = getTok().getLoc();
3873 SMLoc Loc;
4022 SMLoc DirLoc = getLexer().getLoc();
4093 SMLoc DirectiveLoc) {
4108 bool AsmParser::parseDirectiveCFIDefCfa(SMLoc DirectiveLoc) {
4132 bool AsmParser::parseDirectiveCFIRegister(SMLoc DirectiveLoc) {
4163 bool AsmParser::parseDirectiveCFIDefCfaRegister(SMLoc DirectiveLoc) {
4174 bool AsmParser::parseDirectiveCFIOffset(SMLoc DirectiveLoc) {
4189 bool AsmParser::parseDirectiveCFIRelOffset(SMLoc DirectiveLoc) {
4265 bool AsmParser::parseDirectiveCFISameValue(SMLoc DirectiveLoc) {
4277 bool AsmParser::parseDirectiveCFIRestore(SMLoc DirectiveLoc) {
4311 bool AsmParser::parseDirectiveCFIReturnColumn(SMLoc DirectiveLoc) {
4332 bool AsmParser::parseDirectiveCFIUndefined(SMLoc DirectiveLoc) {
4366 bool AsmParser::parseDirectiveMacro(SMLoc DirectiveLoc) {
4395 SMLoc QualLoc;
4415 SMLoc ParamLoc;
4504 void AsmParser::checkForBadMacro(SMLoc DirectiveLoc, StringRef Name,
4635 bool AsmParser::parseDirectivePurgeMacro(SMLoc DirectiveLoc) {
4637 SMLoc Loc;
4659 SMLoc ExprLoc = getLexer().getLoc();
4683 SMLoc Loc = getTok().getLoc();
4715 SMLoc NumBytesLoc = Lexer.getLoc();
4736 SMLoc NumValuesLoc = Lexer.getLoc();
4751 SMLoc ExprLoc = getLexer().getLoc();
4778 SMLoc NumValuesLoc = Lexer.getLoc();
4810 SMLoc NumValuesLoc = Lexer.getLoc();
4858 SMLoc Loc = getTok().getLoc();
4883 SMLoc IDLoc = getLexer().getLoc();
4896 SMLoc SizeLoc = getLexer().getLoc();
4901 SMLoc Pow2AlignmentLoc;
4956 SMLoc Loc = getLexer().getLoc();
4977 SMLoc IncludeLoc = getTok().getLoc();
4998 SMLoc IncbinLoc = getTok().getLoc();
5006 SMLoc SkipLoc, CountLoc;
5036 bool AsmParser::parseDirectiveIf(SMLoc DirectiveLoc, DirectiveKind DirKind) {
5080 bool AsmParser::parseDirectiveIfb(SMLoc DirectiveLoc, bool ExpectBlank) {
5103 bool AsmParser::parseDirectiveIfc(SMLoc DirectiveLoc, bool ExpectEqual) {
5130 bool AsmParser::parseDirectiveIfeqs(SMLoc DirectiveLoc, bool ExpectEqual) {
5168 bool AsmParser::parseDirectiveIfdef(SMLoc DirectiveLoc, bool expect_defined) {
5194 bool AsmParser::parseDirectiveElseIf(SMLoc DirectiveLoc) {
5225 bool AsmParser::parseDirectiveElse(SMLoc DirectiveLoc) {
5248 bool AsmParser::parseDirectiveEnd(SMLoc DirectiveLoc) {
5262 bool AsmParser::parseDirectiveError(SMLoc L, bool WithMessage) {
5287 bool AsmParser::parseDirectiveWarning(SMLoc L) {
5313 bool AsmParser::parseDirectiveEndIf(SMLoc DirectiveLoc) {
5491 MCAsmMacro *AsmParser::parseMacroLikeBody(SMLoc DirectiveLoc) {
5538 void AsmParser::instantiateMacroLikeBody(MCAsmMacro *M, SMLoc DirectiveLoc,
5559 bool AsmParser::parseDirectiveRept(SMLoc DirectiveLoc, StringRef Dir) {
5561 SMLoc CountLoc = getTok().getLoc();
5596 bool AsmParser::parseDirectiveIrp(SMLoc DirectiveLoc) {
5630 bool AsmParser::parseDirectiveIrpc(SMLoc DirectiveLoc) {
5673 bool AsmParser::parseDirectiveEndr(SMLoc DirectiveLoc) {
5685 bool AsmParser::parseDirectiveMSEmit(SMLoc IDLoc, ParseStatementInfo &Info,
5688 SMLoc ExprLoc = getLexer().getLoc();
5702 bool AsmParser::parseDirectiveMSAlign(SMLoc IDLoc, ParseStatementInfo &Info) {
5704 SMLoc ExprLoc = getLexer().getLoc();
5718 bool AsmParser::parseDirectivePrint(SMLoc DirectiveLoc) {
5839 SMLoc Start = SMLoc::getFromPointer(SymName.data());
5839 SMLoc Start = SMLoc::getFromPointer(SymName.data());
6028 SMLoc EqualLoc = Parser.getTok().getLoc();
lib/MC/MCParser/COFFAsmParser.cpp 93 bool ParseSectionDirectiveText(StringRef, SMLoc) {
101 bool ParseSectionDirectiveData(StringRef, SMLoc) {
108 bool ParseSectionDirectiveBSS(StringRef, SMLoc) {
116 bool ParseDirectiveSection(StringRef, SMLoc);
117 bool ParseDirectiveDef(StringRef, SMLoc);
118 bool ParseDirectiveScl(StringRef, SMLoc);
119 bool ParseDirectiveType(StringRef, SMLoc);
120 bool ParseDirectiveEndef(StringRef, SMLoc);
121 bool ParseDirectiveSecRel32(StringRef, SMLoc);
122 bool ParseDirectiveSecIdx(StringRef, SMLoc);
123 bool ParseDirectiveSafeSEH(StringRef, SMLoc);
124 bool ParseDirectiveSymIdx(StringRef, SMLoc);
126 bool ParseDirectiveLinkOnce(StringRef, SMLoc);
127 bool ParseDirectiveRVA(StringRef, SMLoc);
130 bool ParseSEHDirectiveStartProc(StringRef, SMLoc);
131 bool ParseSEHDirectiveEndProc(StringRef, SMLoc);
132 bool ParseSEHDirectiveStartChained(StringRef, SMLoc);
133 bool ParseSEHDirectiveEndChained(StringRef, SMLoc);
134 bool ParseSEHDirectiveHandler(StringRef, SMLoc);
135 bool ParseSEHDirectiveHandlerData(StringRef, SMLoc);
136 bool ParseSEHDirectiveAllocStack(StringRef, SMLoc);
137 bool ParseSEHDirectiveEndProlog(StringRef, SMLoc);
141 bool ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc);
273 bool COFFAsmParser::ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc) {
347 bool COFFAsmParser::ParseDirectiveSection(StringRef, SMLoc) {
406 bool COFFAsmParser::ParseDirectiveDef(StringRef, SMLoc) {
420 bool COFFAsmParser::ParseDirectiveScl(StringRef, SMLoc) {
433 bool COFFAsmParser::ParseDirectiveType(StringRef, SMLoc) {
446 bool COFFAsmParser::ParseDirectiveEndef(StringRef, SMLoc) {
452 bool COFFAsmParser::ParseDirectiveSecRel32(StringRef, SMLoc) {
458 SMLoc OffsetLoc;
481 bool COFFAsmParser::ParseDirectiveRVA(StringRef, SMLoc) {
488 SMLoc OffsetLoc;
512 bool COFFAsmParser::ParseDirectiveSafeSEH(StringRef, SMLoc) {
527 bool COFFAsmParser::ParseDirectiveSecIdx(StringRef, SMLoc) {
542 bool COFFAsmParser::ParseDirectiveSymIdx(StringRef, SMLoc) {
581 bool COFFAsmParser::ParseDirectiveLinkOnce(StringRef, SMLoc Loc) {
605 bool COFFAsmParser::ParseSEHDirectiveStartProc(StringRef, SMLoc Loc) {
620 bool COFFAsmParser::ParseSEHDirectiveEndProc(StringRef, SMLoc Loc) {
626 bool COFFAsmParser::ParseSEHDirectiveStartChained(StringRef, SMLoc Loc) {
632 bool COFFAsmParser::ParseSEHDirectiveEndChained(StringRef, SMLoc Loc) {
638 bool COFFAsmParser::ParseSEHDirectiveHandler(StringRef, SMLoc Loc) {
664 bool COFFAsmParser::ParseSEHDirectiveHandlerData(StringRef, SMLoc Loc) {
670 bool COFFAsmParser::ParseSEHDirectiveAllocStack(StringRef, SMLoc Loc) {
683 bool COFFAsmParser::ParseSEHDirectiveEndProlog(StringRef, SMLoc Loc) {
693 SMLoc startLoc = getLexer().getLoc();
lib/MC/MCParser/DarwinAsmParser.cpp 56 SMLoc LastVersionDirective;
201 bool parseDirectiveAltEntry(StringRef, SMLoc);
202 bool parseDirectiveDesc(StringRef, SMLoc);
203 bool parseDirectiveIndirectSymbol(StringRef, SMLoc);
204 bool parseDirectiveDumpOrLoad(StringRef, SMLoc);
205 bool parseDirectiveLsym(StringRef, SMLoc);
206 bool parseDirectiveLinkerOption(StringRef, SMLoc);
207 bool parseDirectiveSection(StringRef, SMLoc);
208 bool parseDirectivePushSection(StringRef, SMLoc);
209 bool parseDirectivePopSection(StringRef, SMLoc);
210 bool parseDirectivePrevious(StringRef, SMLoc);
211 bool parseDirectiveSecureLogReset(StringRef, SMLoc);
212 bool parseDirectiveSecureLogUnique(StringRef, SMLoc);
213 bool parseDirectiveSubsectionsViaSymbols(StringRef, SMLoc);
214 bool parseDirectiveTBSS(StringRef, SMLoc);
215 bool parseDirectiveZerofill(StringRef, SMLoc);
216 bool parseDirectiveDataRegion(StringRef, SMLoc);
217 bool parseDirectiveDataRegionEnd(StringRef, SMLoc);
220 bool parseSectionDirectiveBss(StringRef, SMLoc) {
224 bool parseSectionDirectiveConst(StringRef, SMLoc) {
228 bool parseSectionDirectiveStaticConst(StringRef, SMLoc) {
232 bool parseSectionDirectiveCString(StringRef, SMLoc) {
237 bool parseSectionDirectiveLiteral4(StringRef, SMLoc) {
242 bool parseSectionDirectiveLiteral8(StringRef, SMLoc) {
247 bool parseSectionDirectiveLiteral16(StringRef, SMLoc) {
252 bool parseSectionDirectiveConstructor(StringRef, SMLoc) {
256 bool parseSectionDirectiveDestructor(StringRef, SMLoc) {
260 bool parseSectionDirectiveFVMLibInit0(StringRef, SMLoc) {
264 bool parseSectionDirectiveFVMLibInit1(StringRef, SMLoc) {
268 bool parseSectionDirectiveSymbolStub(StringRef, SMLoc) {
276 bool parseSectionDirectivePICSymbolStub(StringRef, SMLoc) {
282 bool parseSectionDirectiveData(StringRef, SMLoc) {
286 bool parseSectionDirectiveStaticData(StringRef, SMLoc) {
290 bool parseSectionDirectiveNonLazySymbolPointers(StringRef, SMLoc) {
295 bool parseSectionDirectiveLazySymbolPointers(StringRef, SMLoc) {
300 bool parseSectionDirectiveThreadLocalVariablePointers(StringRef, SMLoc) {
305 bool parseSectionDirectiveDyld(StringRef, SMLoc) {
309 bool parseSectionDirectiveModInitFunc(StringRef, SMLoc) {
314 bool parseSectionDirectiveModTermFunc(StringRef, SMLoc) {
319 bool parseSectionDirectiveConstData(StringRef, SMLoc) {
323 bool parseSectionDirectiveObjCClass(StringRef, SMLoc) {
328 bool parseSectionDirectiveObjCMetaClass(StringRef, SMLoc) {
333 bool parseSectionDirectiveObjCCatClsMeth(StringRef, SMLoc) {
338 bool parseSectionDirectiveObjCCatInstMeth(StringRef, SMLoc) {
343 bool parseSectionDirectiveObjCProtocol(StringRef, SMLoc) {
348 bool parseSectionDirectiveObjCStringObject(StringRef, SMLoc) {
353 bool parseSectionDirectiveObjCClsMeth(StringRef, SMLoc) {
358 bool parseSectionDirectiveObjCInstMeth(StringRef, SMLoc) {
363 bool parseSectionDirectiveObjCClsRefs(StringRef, SMLoc) {
369 bool parseSectionDirectiveObjCMessageRefs(StringRef, SMLoc) {
375 bool parseSectionDirectiveObjCSymbols(StringRef, SMLoc) {
380 bool parseSectionDirectiveObjCCategory(StringRef, SMLoc) {
385 bool parseSectionDirectiveObjCClassVars(StringRef, SMLoc) {
390 bool parseSectionDirectiveObjCInstanceVars(StringRef, SMLoc) {
395 bool parseSectionDirectiveObjCModuleInfo(StringRef, SMLoc) {
400 bool parseSectionDirectiveObjCClassNames(StringRef, SMLoc) {
405 bool parseSectionDirectiveObjCMethVarTypes(StringRef, SMLoc) {
410 bool parseSectionDirectiveObjCMethVarNames(StringRef, SMLoc) {
415 bool parseSectionDirectiveObjCSelectorStrs(StringRef, SMLoc) {
420 bool parseSectionDirectiveTData(StringRef, SMLoc) {
425 bool parseSectionDirectiveText(StringRef, SMLoc) {
430 bool parseSectionDirectiveTLV(StringRef, SMLoc) {
435 bool parseSectionDirectiveIdent(StringRef, SMLoc) {
441 bool parseSectionDirectiveThreadInitFunc(StringRef, SMLoc) {
446 bool parseWatchOSVersionMin(StringRef Directive, SMLoc Loc) {
449 bool parseTvOSVersionMin(StringRef Directive, SMLoc Loc) {
452 bool parseIOSVersionMin(StringRef Directive, SMLoc Loc) {
455 bool parseMacOSXVersionMin(StringRef Directive, SMLoc Loc) {
459 bool parseBuildVersion(StringRef Directive, SMLoc Loc);
460 bool parseVersionMin(StringRef Directive, SMLoc Loc, MCVersionMinType Type);
467 void checkVersion(StringRef Directive, StringRef Arg, SMLoc Loc,
502 bool DarwinAsmParser::parseDirectiveAltEntry(StringRef, SMLoc) {
522 bool DarwinAsmParser::parseDirectiveDesc(StringRef, SMLoc) {
551 bool DarwinAsmParser::parseDirectiveIndirectSymbol(StringRef, SMLoc Loc) {
586 SMLoc IDLoc) {
608 bool DarwinAsmParser::parseDirectiveLinkerOption(StringRef IDVal, SMLoc) {
634 bool DarwinAsmParser::parseDirectiveLsym(StringRef, SMLoc) {
664 bool DarwinAsmParser::parseDirectiveSection(StringRef, SMLoc) {
665 SMLoc Loc = getLexer().getLoc();
713 SMLoc BLoc = SMLoc::getFromPointer(SectionVal.data() + B);
713 SMLoc BLoc = SMLoc::getFromPointer(SectionVal.data() + B);
714 SMLoc ELoc = SMLoc::getFromPointer(SectionVal.data() + E);
714 SMLoc ELoc = SMLoc::getFromPointer(SectionVal.data() + E);
732 bool DarwinAsmParser::parseDirectivePushSection(StringRef S, SMLoc Loc) {
745 bool DarwinAsmParser::parseDirectivePopSection(StringRef, SMLoc) {
753 bool DarwinAsmParser::parseDirectivePrevious(StringRef DirName, SMLoc) {
763 bool DarwinAsmParser::parseDirectiveSecureLogUnique(StringRef, SMLoc IDLoc) {
803 bool DarwinAsmParser::parseDirectiveSecureLogReset(StringRef, SMLoc IDLoc) {
816 bool DarwinAsmParser::parseDirectiveSubsectionsViaSymbols(StringRef, SMLoc) {
829 bool DarwinAsmParser::parseDirectiveTBSS(StringRef, SMLoc) {
830 SMLoc IDLoc = getLexer().getLoc();
843 SMLoc SizeLoc = getLexer().getLoc();
848 SMLoc Pow2AlignmentLoc;
885 bool DarwinAsmParser::parseDirectiveZerofill(StringRef, SMLoc) {
895 SMLoc SectionLoc = getLexer().getLoc();
915 SMLoc IDLoc = getLexer().getLoc();
928 SMLoc SizeLoc = getLexer().getLoc();
933 SMLoc Pow2AlignmentLoc;
973 bool DarwinAsmParser::parseDirectiveDataRegion(StringRef, SMLoc) {
980 SMLoc Loc = getParser().getTok().getLoc();
998 bool DarwinAsmParser::parseDirectiveDataRegionEnd(StringRef, SMLoc) {
1094 SMLoc Loc, Triple::OSType ExpectedOS) {
1123 bool DarwinAsmParser::parseVersionMin(StringRef Directive, SMLoc Loc,
1161 bool DarwinAsmParser::parseBuildVersion(StringRef Directive, SMLoc Loc) {
1163 SMLoc PlatformLoc = getTok().getLoc();
lib/MC/MCParser/ELFAsmParser.cpp 92 bool ParseSectionDirectiveData(StringRef, SMLoc) {
97 bool ParseSectionDirectiveText(StringRef, SMLoc) {
102 bool ParseSectionDirectiveBSS(StringRef, SMLoc) {
107 bool ParseSectionDirectiveRoData(StringRef, SMLoc) {
112 bool ParseSectionDirectiveTData(StringRef, SMLoc) {
118 bool ParseSectionDirectiveTBSS(StringRef, SMLoc) {
124 bool ParseSectionDirectiveDataRel(StringRef, SMLoc) {
129 bool ParseSectionDirectiveDataRelRo(StringRef, SMLoc) {
135 bool ParseSectionDirectiveEhFrame(StringRef, SMLoc) {
140 bool ParseDirectivePushSection(StringRef, SMLoc);
141 bool ParseDirectivePopSection(StringRef, SMLoc);
142 bool ParseDirectiveSection(StringRef, SMLoc);
143 bool ParseDirectiveSize(StringRef, SMLoc);
144 bool ParseDirectivePrevious(StringRef, SMLoc);
145 bool ParseDirectiveType(StringRef, SMLoc);
146 bool ParseDirectiveIdent(StringRef, SMLoc);
147 bool ParseDirectiveSymver(StringRef, SMLoc);
148 bool ParseDirectiveVersion(StringRef, SMLoc);
149 bool ParseDirectiveWeakref(StringRef, SMLoc);
150 bool ParseDirectiveSymbolAttribute(StringRef, SMLoc);
151 bool ParseDirectiveSubsection(StringRef, SMLoc);
152 bool ParseDirectiveCGProfile(StringRef, SMLoc);
156 bool ParseSectionArguments(bool IsPush, SMLoc loc);
169 bool ELFAsmParser::ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc) {
217 bool ELFAsmParser::ParseDirectiveSize(StringRef, SMLoc) {
242 SMLoc FirstLoc = getLexer().getLoc();
252 SMLoc PrevLoc = getLexer().getLoc();
370 bool ELFAsmParser::ParseDirectivePushSection(StringRef s, SMLoc loc) {
381 bool ELFAsmParser::ParseDirectivePopSection(StringRef, SMLoc) {
387 bool ELFAsmParser::ParseDirectiveSection(StringRef, SMLoc loc) {
486 bool ELFAsmParser::ParseSectionArguments(bool IsPush, SMLoc loc) {
658 bool ELFAsmParser::ParseDirectivePrevious(StringRef DirName, SMLoc) {
686 bool ELFAsmParser::ParseDirectiveType(StringRef, SMLoc) {
718 SMLoc TypeLoc = getLexer().getLoc();
739 bool ELFAsmParser::ParseDirectiveIdent(StringRef, SMLoc) {
757 bool ELFAsmParser::ParseDirectiveSymver(StringRef, SMLoc) {
788 bool ELFAsmParser::ParseDirectiveVersion(StringRef, SMLoc) {
812 bool ELFAsmParser::ParseDirectiveWeakref(StringRef, SMLoc) {
836 bool ELFAsmParser::ParseDirectiveSubsection(StringRef, SMLoc) {
854 bool ELFAsmParser::ParseDirectiveCGProfile(StringRef, SMLoc) {
856 SMLoc FromLoc = getLexer().getLoc();
865 SMLoc ToLoc = getLexer().getLoc();
lib/MC/MCParser/MCAsmLexer.cpp 23 SMLoc MCAsmLexer::getLoc() const {
24 return SMLoc::getFromPointer(TokStart);
27 SMLoc AsmToken::getLoc() const {
28 return SMLoc::getFromPointer(Str.data());
31 SMLoc AsmToken::getEndLoc() const {
32 return SMLoc::getFromPointer(Str.data() + Str.size());
lib/MC/MCParser/MCAsmParser.cpp 37 bool MCAsmParser::parseTokenLoc(SMLoc &Loc) {
77 bool MCAsmParser::check(bool P, SMLoc Loc, const Twine &Msg) {
87 bool MCAsmParser::Error(SMLoc L, const Twine &Msg, SMRange Range) {
127 SMLoc L;
lib/MC/MCParser/WasmAsmParser.cpp 88 bool parseSectionDirectiveText(StringRef, SMLoc) {
106 bool parseSectionDirective(StringRef, SMLoc) {
158 bool parseDirectiveSize(StringRef, SMLoc) {
176 bool parseDirectiveType(StringRef, SMLoc) {
205 bool ParseDirectiveIdent(StringRef, SMLoc) {
220 bool ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc) {
lib/MC/MCStreamer.cpp 162 void MCStreamer::EmitValue(const MCExpr *Value, unsigned Size, SMLoc Loc) {
285 SMLoc Loc) {
299 StringRef FileName, SMLoc Loc) {}
302 SMLoc Loc) {
400 void MCStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
422 void MCStreamer::EmitCFIStartProc(bool IsSimple, SMLoc Loc) {
656 WinEH::FrameInfo *MCStreamer::EnsureValidWinFrameInfo(SMLoc Loc) {
671 void MCStreamer::EmitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc) {
688 void MCStreamer::EmitWinCFIEndProc(SMLoc Loc) {
699 void MCStreamer::EmitWinCFIFuncletOrFuncEnd(SMLoc Loc) {
710 void MCStreamer::EmitWinCFIStartChained(SMLoc Loc) {
723 void MCStreamer::EmitWinCFIEndChained(SMLoc Loc) {
738 SMLoc Loc) {
754 void MCStreamer::EmitWinEHHandlerData(SMLoc Loc) {
819 void MCStreamer::EmitWinCFIPushReg(MCRegister Register, SMLoc Loc) {
832 SMLoc Loc) {
853 void MCStreamer::EmitWinCFIAllocStack(unsigned Size, SMLoc Loc) {
871 SMLoc Loc) {
888 SMLoc Loc) {
902 void MCStreamer::EmitWinCFIPushFrame(bool Code, SMLoc Loc) {
916 void MCStreamer::EmitWinCFIEndProlog(SMLoc Loc) {
1081 void MCStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) {
1086 void MCStreamer::emitFill(const MCExpr &NumBytes, uint64_t Value, SMLoc Loc) {}
1088 SMLoc Loc) {}
1095 SMLoc Loc) {}
lib/MC/MCWasmStreamer.cpp 152 SMLoc Loc) {
222 SMLoc Loc) {
lib/MC/MCWinCOFFStreamer.cpp 85 void MCWinCOFFStreamer::EmitLabel(MCSymbol *S, SMLoc Loc) {
313 SMLoc Loc) {
327 void MCWinCOFFStreamer::EmitWinEHHandlerData(SMLoc Loc) {
lib/MC/MCXCOFFStreamer.cpp 66 SMLoc Loc) {
lib/Object/RecordStreamer.cpp 89 void RecordStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
110 SMLoc Loc) {
lib/Object/RecordStreamer.h 50 void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
54 unsigned ByteAlignment, SMLoc Loc = SMLoc()) override;
lib/Support/FileCheck.cpp 233 SMLoc OpLoc = SMLoc::getFromPointer(Expr.data());
233 SMLoc OpLoc = SMLoc::getFromPointer(Expr.data());
325 PatternLoc = SMLoc::getFromPointer(PatternStr.data());
379 SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()),
418 SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()),
443 SM.PrintMessage(SMLoc::getFromPointer(MatchStr.data() + SpacePos),
463 SM.PrintMessage(SMLoc::getFromPointer(Name.data()),
474 SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error,
556 SM.PrintMessage(SMLoc::getFromPointer(SubstStr.data()),
596 SM.PrintMessage(SMLoc::getFromPointer(RS.data()), SourceMgr::DK_Error,
757 SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()),
764 const SourceMgr &SM, SMLoc Loc,
769 SMLoc Start = SMLoc::getFromPointer(Buffer.data() + Pos);
769 SMLoc Start = SMLoc::getFromPointer(Buffer.data() + Pos);
770 SMLoc End = SMLoc::getFromPointer(Buffer.data() + Pos + Len);
770 SMLoc End = SMLoc::getFromPointer(Buffer.data() + Pos + Len);
883 SM.PrintMessage(SMLoc::getFromPointer(Str.data()),
930 SMLoc CheckLoc, MatchType MatchTy,
1194 SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Error,
1201 SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Error,
1216 SMLoc PatternLoc = SMLoc::getFromPointer(Buffer.data());
1216 SMLoc PatternLoc = SMLoc::getFromPointer(Buffer.data());
1226 SMLoc::getFromPointer(UsedPrefixStart), SourceMgr::DK_Error,
1241 SM.PrintMessage(SMLoc::getFromPointer(UsedPrefixStart),
1265 *Req.CheckPrefixes.begin(), SMLoc::getFromPointer(Buffer.data()));
1289 StringRef Prefix, SMLoc Loc, const FileCheckPattern &Pat,
1335 StringRef Prefix, SMLoc Loc,
1523 SM.PrintMessage(SMLoc::getFromPointer(Buffer.end()), SourceMgr::DK_Note,
1525 SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note,
1534 SM.PrintMessage(SMLoc::getFromPointer(Buffer.end()), SourceMgr::DK_Note,
1536 SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note,
1538 SM.PrintMessage(SMLoc::getFromPointer(FirstNewLine), SourceMgr::DK_Note,
1558 SM.PrintMessage(SMLoc::getFromPointer(Buffer.end()), SourceMgr::DK_Note,
1560 SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note,
1685 SMLoc OldStart = SMLoc::getFromPointer(Buffer.data() + MI->Pos);
1685 SMLoc OldStart = SMLoc::getFromPointer(Buffer.data() + MI->Pos);
1686 SMLoc OldEnd = SMLoc::getFromPointer(Buffer.data() + MI->End);
1686 SMLoc OldEnd = SMLoc::getFromPointer(Buffer.data() + MI->End);
lib/Support/FileCheckImpl.h 340 static Error get(const SourceMgr &SM, SMLoc Loc, const Twine &ErrMsg) {
346 return get(SM, SMLoc::getFromPointer(Buffer.data()), ErrMsg);
365 SMLoc PatternLoc;
440 SMLoc getLoc() const { return PatternLoc; }
588 SMLoc Loc;
594 FileCheckString(const FileCheckPattern &P, StringRef S, SMLoc L)
lib/Support/SourceMgr.cpp 41 SMLoc IncludeLoc,
61 unsigned SourceMgr::FindBufferContainingLoc(SMLoc Loc) const {
125 SourceMgr::getLineAndColumn(SMLoc Loc, unsigned BufferID) const {
150 void SourceMgr::PrintIncludeStack(SMLoc IncludeLoc, raw_ostream &OS) const {
163 SMDiagnostic SourceMgr::GetMessage(SMLoc Loc, SourceMgr::DiagKind Kind,
207 R.Start = SMLoc::getFromPointer(LineStart);
209 R.End = SMLoc::getFromPointer(LineEnd);
242 void SourceMgr::PrintMessage(raw_ostream &OS, SMLoc Loc,
249 void SourceMgr::PrintMessage(SMLoc Loc, SourceMgr::DiagKind Kind,
259 SMDiagnostic::SMDiagnostic(const SourceMgr &sm, SMLoc L, StringRef FN,
lib/Support/YAMLParser.cpp 265 void printError(SMLoc Loc, SourceMgr::DiagKind Kind, const Twine &Message,
281 printError(SMLoc::getFromPointer(Current), SourceMgr::DK_Error, Message);
1804 SMLoc Start = SMLoc::getFromPointer(peekNext().Range.begin());
1804 SMLoc Start = SMLoc::getFromPointer(peekNext().Range.begin());
lib/TableGen/Error.cpp 26 static void PrintMessage(ArrayRef<SMLoc> Loc, SourceMgr::DiagKind Kind,
33 SMLoc NullLoc;
44 void PrintNote(ArrayRef<SMLoc> NoteLoc, const Twine &Msg) {
48 void PrintWarning(ArrayRef<SMLoc> WarningLoc, const Twine &Msg) {
53 SrcMgr.PrintMessage(SMLoc::getFromPointer(Loc), SourceMgr::DK_Warning, Msg);
58 void PrintError(ArrayRef<SMLoc> ErrorLoc, const Twine &Msg) {
63 SrcMgr.PrintMessage(SMLoc::getFromPointer(Loc), SourceMgr::DK_Error, Msg);
75 void PrintFatalError(ArrayRef<SMLoc> ErrorLoc, const Twine &Msg) {
lib/TableGen/Record.cpp 517 CodeInit *CodeInit::get(StringRef V, const SMLoc &Loc) {
1933 Record *DagInit::getOperatorAsDef(ArrayRef<SMLoc> Loc) const {
lib/TableGen/TGLexer.cpp 63 SMLoc TGLexer::getLoc() const {
64 return SMLoc::getFromPointer(TokStart);
69 tgtok::TokKind TGLexer::ReturnError(SMLoc Loc, const Twine &Msg) {
75 return ReturnError(SMLoc::getFromPointer(Loc), Msg);
79 SMLoc ParentIncludeLoc = SrcMgr.getParentIncludeLoc(CurBuffer);
375 CurBuffer = SrcMgr.AddIncludeFile(Filename, SMLoc::getFromPointer(CurPtr),
697 {Kind, MacroIsDefined, SMLoc::getFromPointer(TokStart)});
738 {Kind, !IfdefEntry.IsDefined, SMLoc::getFromPointer(TokStart)});
lib/TableGen/TGLexer.h 90 typedef std::map<std::string, SMLoc> DependenciesMapTy;
124 SMLoc getLoc() const;
130 tgtok::TokKind ReturnError(SMLoc Loc, const Twine &Msg);
191 SMLoc SrcPos;
lib/TableGen/TGParser.cpp 140 bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) {
159 bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName,
373 SMLoc *Loc) {
410 std::vector<RecordsEntry> *Dest, SMLoc *Loc) {
749 SMLoc StartLoc = Lex.getLoc();
771 SMLoc StartLoc = Lex.getLoc();
847 Init *TGParser::ParseIDValue(Record *CurRec, StringInit *Name, SMLoc NameLoc,
1060 SMLoc OpLoc = Lex.getLoc();
1145 SMLoc InitLoc = Lex.getLoc();
1255 SMLoc OpLoc = Lex.getLoc();
1402 SMLoc MHSLoc = Lex.getLoc();
1413 SMLoc RHSLoc = Lex.getLoc();
1815 SMLoc NameLoc = Lex.getLoc();
1880 SMLoc BraceLoc = Lex.getLoc();
2117 SMLoc CurlyLoc = Lex.getLoc();
2140 SMLoc SquareLoc = Lex.getLoc();
2177 SMLoc PasteLoc = Lex.getLoc();
2392 SMLoc IdLoc = Lex.getLoc();
2413 SMLoc ValLoc = Lex.getLoc();
2466 SMLoc ValueLoc = Lex.getLoc();
2536 SMLoc Loc = Lex.getLoc();
2573 SMLoc IdLoc = Lex.getLoc();
2694 SMLoc DefLoc = Lex.getLoc();
2743 SMLoc BraceLoc = Lex.getLoc();
2770 SMLoc Loc = Lex.getLoc();
2793 SMLoc BraceLoc = Lex.getLoc();
2867 SMLoc NameLoc = Lex.getLoc();
2926 SMLoc BraceLoc = Lex.getLoc();
3067 SMLoc SubClassLoc = Lex.getLoc();
lib/TableGen/TGParser.h 38 SMLoc Loc;
39 LetRecord(StringInit *N, ArrayRef<unsigned> B, Init *V, SMLoc L)
60 SMLoc Loc;
67 ForeachLoop(SMLoc Loc, VarInit *IVar, Init *LValue)
72 SMLoc Loc;
83 MultiClass(StringRef Name, SMLoc Loc, RecordKeeper &Records) :
125 bool Error(SMLoc L, const Twine &Msg) const {
137 bool AddValue(Record *TheRec, SMLoc Loc, const RecordVal &RV);
138 bool SetValue(Record *TheRec, SMLoc Loc, Init *ValName,
150 std::vector<RecordsEntry> *Dest, SMLoc *Loc = nullptr);
153 SMLoc *Loc = nullptr);
179 Init *ParseIDValue(Record *CurRec, StringInit *Name, SMLoc NameLoc,
lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp 150 SMLoc getLoc() const { return getParser().getTok().getLoc(); }
152 bool parseSysAlias(StringRef Name, SMLoc NameLoc, OperandVector &Operands);
153 void createSysAlias(uint16_t Encoding, OperandVector &Operands, SMLoc S);
164 bool showMatchError(SMLoc Loc, unsigned ErrCode, uint64_t ErrorInfo,
167 bool parseDirectiveArch(SMLoc L);
168 bool parseDirectiveArchExtension(SMLoc L);
169 bool parseDirectiveCPU(SMLoc L);
170 bool parseDirectiveInst(SMLoc L);
172 bool parseDirectiveTLSDescCall(SMLoc L);
174 bool parseDirectiveLOH(StringRef LOH, SMLoc L);
175 bool parseDirectiveLtorg(SMLoc L);
177 bool parseDirectiveReq(StringRef Name, SMLoc L);
178 bool parseDirectiveUnreq(SMLoc L);
182 bool validateInstruction(MCInst &Inst, SMLoc &IDLoc,
183 SmallVectorImpl<SMLoc> &Loc);
184 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
261 SMLoc NameLoc, OperandVector &Operands) override;
262 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
262 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
295 SMLoc StartLoc, EndLoc;
485 SMLoc getStartLoc() const override { return StartLoc; }
487 SMLoc getEndLoc() const override { return EndLoc; }
1802 CreateToken(StringRef Str, bool IsSuffix, SMLoc S, MCContext &Ctx) {
1813 CreateReg(unsigned RegNum, RegKind Kind, SMLoc S, SMLoc E, MCContext &Ctx,
1813 CreateReg(unsigned RegNum, RegKind Kind, SMLoc S, SMLoc E, MCContext &Ctx,
1833 SMLoc S, SMLoc E, MCContext &Ctx,
1833 SMLoc S, SMLoc E, MCContext &Ctx,
1848 unsigned ElementWidth, RegKind RegisterKind, SMLoc S, SMLoc E,
1848 unsigned ElementWidth, RegKind RegisterKind, SMLoc S, SMLoc E,
1862 CreateVectorIndex(unsigned Idx, SMLoc S, SMLoc E, MCContext &Ctx) {
1862 CreateVectorIndex(unsigned Idx, SMLoc S, SMLoc E, MCContext &Ctx) {
1870 static std::unique_ptr<AArch64Operand> CreateImm(const MCExpr *Val, SMLoc S,
1871 SMLoc E, MCContext &Ctx) {
1881 SMLoc S, SMLoc E,
1881 SMLoc S, SMLoc E,
1892 CreateCondCode(AArch64CC::CondCode Code, SMLoc S, SMLoc E, MCContext &Ctx) {
1892 CreateCondCode(AArch64CC::CondCode Code, SMLoc S, SMLoc E, MCContext &Ctx) {
1901 CreateFPImm(APFloat Val, bool IsExact, SMLoc S, MCContext &Ctx) {
1912 SMLoc S,
1923 static std::unique_ptr<AArch64Operand> CreateSysReg(StringRef Str, SMLoc S,
1939 static std::unique_ptr<AArch64Operand> CreateSysCR(unsigned Val, SMLoc S,
1940 SMLoc E, MCContext &Ctx) {
1950 SMLoc S,
1963 SMLoc S,
1976 SMLoc S,
1989 bool HasExplicitAmount, SMLoc S, SMLoc E, MCContext &Ctx) {
1989 bool HasExplicitAmount, SMLoc S, SMLoc E, MCContext &Ctx) {
2243 bool AArch64AsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
2244 SMLoc &EndLoc) {
2247 EndLoc = SMLoc::getFromPointer(getLoc().getPointer() - 1);
2316 SMLoc S = getLoc();
2347 SMLoc S = getLoc();
2416 SMLoc S = getLoc();
2439 SMLoc S = getLoc();
2463 SMLoc S = getLoc();
2504 SMLoc E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
2504 SMLoc E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
2514 SMLoc S = getLoc();
2542 SMLoc E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
2542 SMLoc E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
2552 SMLoc S = getLoc();
2605 SMLoc S = getLoc();
2617 SMLoc E = Parser.getTok().getLoc();
2653 SMLoc E = Parser.getTok().getLoc();
2658 SMLoc E = Parser.getTok().getLoc();
2709 SMLoc S = getLoc();
2757 SMLoc S = Tok.getLoc();
2772 SMLoc E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
2772 SMLoc E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
2780 SMLoc E = Parser.getTok().getLoc();
2798 E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
2861 SMLoc S) {
2882 bool AArch64AsmParser::parseSysAlias(StringRef Name, SMLoc NameLoc,
2894 SMLoc S = Tok.getLoc();
2990 SMLoc ExprLoc = getLoc();
3070 SMLoc S = getLoc();
3099 SMLoc SIdx = getLoc();
3110 SMLoc E = getLoc();
3163 const SMLoc S = getLoc();
3332 SMLoc S = getLoc();
3352 SMLoc Loc = getLoc();
3377 SMLoc Loc = getLoc();
3435 SMLoc StartLoc = getLoc();
3470 SMLoc StartLoc = getLoc();
3527 SMLoc S = getLoc();
3563 SMLoc S, E;
3566 SMLoc S = getLoc();
3571 SMLoc E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
3571 SMLoc E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
3576 SMLoc Loc = Parser.getTok().getLoc();
3613 E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
3661 E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
3666 SMLoc Loc = getLoc();
3683 E = SMLoc::getFromPointer(Loc.getPointer() - 1);
3742 StringRef Name, SMLoc NameLoc,
3795 SMLoc SuffixLoc = SMLoc::getFromPointer(NameLoc.getPointer() +
3795 SMLoc SuffixLoc = SMLoc::getFromPointer(NameLoc.getPointer() +
3811 SMLoc SuffixLoc = SMLoc::getFromPointer(NameLoc.getPointer() +
3811 SMLoc SuffixLoc = SMLoc::getFromPointer(NameLoc.getPointer() +
3856 SMLoc RLoc = Parser.getTok().getLoc();
3860 SMLoc ELoc = Parser.getTok().getLoc();
3888 bool AArch64AsmParser::validateInstruction(MCInst &Inst, SMLoc &IDLoc,
3889 SmallVectorImpl<SMLoc> &Loc) {
4167 bool AArch64AsmParser::showMatchError(SMLoc Loc, unsigned ErrCode,
4489 bool AArch64AsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
4813 SmallVector<SMLoc, 8> OperandLocs;
4840 SMLoc ErrorLoc = IDLoc;
5005 SMLoc ErrorLoc = ((AArch64Operand &)*Operands[ErrorInfo]).getStartLoc();
5022 SMLoc Loc = DirectiveID.getLoc();
5103 bool AArch64AsmParser::parseDirectiveArch(SMLoc L) {
5104 SMLoc ArchLoc = getLoc();
5163 bool AArch64AsmParser::parseDirectiveArchExtension(SMLoc L) {
5164 SMLoc ExtLoc = getLoc();
5199 static SMLoc incrementLoc(SMLoc L, int Offset) {
5199 static SMLoc incrementLoc(SMLoc L, int Offset) {
5200 return SMLoc::getFromPointer(L.getPointer() + Offset);
5205 bool AArch64AsmParser::parseDirectiveCPU(SMLoc L) {
5206 SMLoc CurLoc = getLoc();
5273 bool AArch64AsmParser::parseDirectiveInst(SMLoc Loc) {
5278 SMLoc L = getLoc();
5296 bool AArch64AsmParser::parseDirectiveTLSDescCall(SMLoc L) {
5317 bool AArch64AsmParser::parseDirectiveLOH(StringRef IDVal, SMLoc Loc) {
5368 bool AArch64AsmParser::parseDirectiveLtorg(SMLoc L) {
5377 bool AArch64AsmParser::parseDirectiveReq(StringRef Name, SMLoc L) {
5380 SMLoc SRegLoc = getLoc();
5441 bool AArch64AsmParser::parseDirectiveUnreq(SMLoc L) {
5591 SMLoc S = getLoc();
5632 SMLoc E = getLoc();
5664 const SMLoc S = getLoc();
5717 SMLoc SS = getLoc();
lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.cpp 139 void EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override {
145 SMLoc Loc) override {
lib/Target/AArch64/MCTargetDesc/AArch64TargetStreamer.cpp 32 SMLoc Loc) {
lib/Target/AArch64/MCTargetDesc/AArch64TargetStreamer.h 30 const MCExpr *addConstantPoolEntry(const MCExpr *, unsigned Size, SMLoc Loc);
lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFStreamer.cpp 29 void EmitWinEHHandlerData(SMLoc Loc) override;
34 void AArch64WinCOFFStreamer::EmitWinEHHandlerData(SMLoc Loc) {
lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp 86 SMLoc StartLoc, EndLoc;
699 SMLoc getStartLoc() const override {
703 SMLoc getEndLoc() const override {
896 int64_t Val, SMLoc Loc,
910 StringRef Str, SMLoc Loc,
921 unsigned RegNo, SMLoc S,
922 SMLoc E) {
932 const class MCExpr *Expr, SMLoc S) {
1230 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
1230 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
1234 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
1243 SMLoc NameLoc, OperandVector &Operands) override;
1303 const SMLoc Loc);
1309 const SMLoc Loc);
1313 SMLoc getFlatOffsetLoc(const OperandVector &Operands) const;
1315 bool validateInstruction(const MCInst &Inst, const SMLoc &IDLoc, const OperandVector &Operands);
1351 SMLoc getLoc() const;
1981 bool AMDGPUAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
1982 SMLoc &EndLoc) {
2318 SMLoc StartLoc = Tok.getLoc();
2319 SMLoc EndLoc = Tok.getEndLoc();
2346 SMLoc S = getLoc();
2380 SMLoc S = getLoc();
2390 SMLoc EndLoc;
2530 SMLoc Loc;
2638 auto Loc = getLoc();
3253 SMLoc AMDGPUAsmParser::getFlatOffsetLoc(const OperandVector &Operands) const {
3405 const SMLoc &IDLoc,
3483 bool AMDGPUAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
3534 SMLoc ErrorLoc = IDLoc;
3586 SMLoc TargetStart = getTok().getLoc();
3692 SMLoc ValStart = getTok().getLoc();
3696 SMLoc ValEnd = getTok().getLoc();
4251 SMLoc NameLoc = getLexer().getLoc();
4262 SMLoc SizeLoc = getLexer().getLoc();
4273 SMLoc AlignLoc = getLexer().getLoc();
4429 SMLoc LBraceLoc = getTok().getLoc();
4483 SMLoc NameLoc, OperandVector &Operands) {
4539 SMLoc S = getLoc();
4559 SMLoc S = getLoc();
4573 SMLoc Loc = getLoc();
4604 SMLoc S = Parser.getTok().getLoc();
4681 SMLoc S = Parser.getTok().getLoc();
4877 SMLoc CntLoc = getLoc();
4885 SMLoc ValLoc = getLoc();
4927 SMLoc S = getLoc();
4981 const SMLoc Loc) {
5006 SMLoc Loc = getLoc();
5071 const SMLoc S) {
5105 SMLoc Loc = getLoc();
5145 SMLoc S = Parser.getTok().getLoc();
5179 SMLoc S = Parser.getTok().getLoc();
5186 SMLoc SChan = SMLoc::getFromPointer(Chan.data());
5186 SMLoc SChan = SMLoc::getFromPointer(Chan.data());
5275 SMLoc S = Parser.getTok().getLoc();
5347 SMLoc S = getLoc();
5397 SMLoc
5438 SMLoc ExprLoc = Parser.getTok().getLoc();
5471 SMLoc S = Parser.getTok().getLoc();
5497 SMLoc S = Parser.getTok().getLoc();
5517 SMLoc S = Parser.getTok().getLoc();
5542 SMLoc StrLoc = Parser.getTok().getLoc();
5583 SMLoc OffsetLoc = Parser.getTok().getLoc();
5601 SMLoc ModeLoc = Parser.getTok().getLoc();
5626 SMLoc S = Parser.getTok().getLoc();
5671 SMLoc S = Parser.getTok().getLoc();
5707 SMLoc S = Parser.getTok().getLoc();
5754 SMLoc Loc = Opr.getStartLoc();
6444 SMLoc S = Parser.getTok().getLoc();
6461 SMLoc Loc = getLexer().getTok().getEndLoc();
6487 SMLoc S = Parser.getTok().getLoc();
6546 SMLoc S = Parser.getTok().getLoc();
6752 SMLoc S = Parser.getTok().getLoc();
6785 SMLoc S = Parser.getTok().getLoc();
7013 SMLoc S = Parser.getTok().getLoc();
lib/Target/ARM/AsmParser/ARMAsmParser.cpp 109 using Locs = SmallVector<SMLoc, 4>;
130 void recordFnStart(SMLoc L) { FnStartLocs.push_back(L); }
131 void recordCantUnwind(SMLoc L) { CantUnwindLocs.push_back(L); }
132 void recordPersonality(SMLoc L) { PersonalityLocs.push_back(L); }
133 void recordHandlerData(SMLoc L) { HandlerDataLocs.push_back(L); }
134 void recordPersonalityIndex(SMLoc L) { PersonalityIndexLocs.push_back(L); }
377 void Note(SMLoc L, const Twine &Msg, SMRange Range = None) {
381 bool Warning(SMLoc L, const Twine &Msg, SMRange Range = None) {
385 bool Error(SMLoc L, const Twine &Msg, SMRange Range = None) {
403 bool parseLiteralValues(unsigned Size, SMLoc L);
404 bool parseDirectiveThumb(SMLoc L);
405 bool parseDirectiveARM(SMLoc L);
406 bool parseDirectiveThumbFunc(SMLoc L);
407 bool parseDirectiveCode(SMLoc L);
408 bool parseDirectiveSyntax(SMLoc L);
409 bool parseDirectiveReq(StringRef Name, SMLoc L);
410 bool parseDirectiveUnreq(SMLoc L);
411 bool parseDirectiveArch(SMLoc L);
412 bool parseDirectiveEabiAttr(SMLoc L);
413 bool parseDirectiveCPU(SMLoc L);
414 bool parseDirectiveFPU(SMLoc L);
415 bool parseDirectiveFnStart(SMLoc L);
416 bool parseDirectiveFnEnd(SMLoc L);
417 bool parseDirectiveCantUnwind(SMLoc L);
418 bool parseDirectivePersonality(SMLoc L);
419 bool parseDirectiveHandlerData(SMLoc L);
420 bool parseDirectiveSetFP(SMLoc L);
421 bool parseDirectivePad(SMLoc L);
422 bool parseDirectiveRegSave(SMLoc L, bool IsVector);
423 bool parseDirectiveInst(SMLoc L, char Suffix = '\0');
424 bool parseDirectiveLtorg(SMLoc L);
425 bool parseDirectiveEven(SMLoc L);
426 bool parseDirectivePersonalityIndex(SMLoc L);
427 bool parseDirectiveUnwindRaw(SMLoc L);
428 bool parseDirectiveTLSDescSeq(SMLoc L);
429 bool parseDirectiveMovSP(SMLoc L);
430 bool parseDirectiveObjectArch(SMLoc L);
431 bool parseDirectiveArchExtension(SMLoc L);
432 bool parseDirectiveAlign(SMLoc L);
433 bool parseDirectiveThumbSet(SMLoc L);
534 void FixModeAfterArchChange(bool WasThumb, SMLoc Loc);
576 SMLoc &EndLoc);
630 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
630 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
632 SMLoc NameLoc, OperandVector &Operands) override;
639 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
649 SMLoc Loc;
657 SMLoc IDLoc, OperandVector &Operands);
658 void ReportNearMisses(SmallVectorImpl<NearMissInfo> &NearMisses, SMLoc IDLoc,
707 SMLoc StartLoc, EndLoc, AlignmentLoc;
863 SMLoc getStartLoc() const override { return StartLoc; }
866 SMLoc getEndLoc() const override { return EndLoc; }
873 SMLoc getAlignmentLoc() const {
3382 static std::unique_ptr<ARMOperand> CreateITMask(unsigned Mask, SMLoc S) {
3391 SMLoc S) {
3400 SMLoc S) {
3408 static std::unique_ptr<ARMOperand> CreateCoprocNum(unsigned CopVal, SMLoc S) {
3416 static std::unique_ptr<ARMOperand> CreateCoprocReg(unsigned CopVal, SMLoc S) {
3424 static std::unique_ptr<ARMOperand> CreateCoprocOption(unsigned Val, SMLoc S,
3425 SMLoc E) {
3433 static std::unique_ptr<ARMOperand> CreateCCOut(unsigned RegNum, SMLoc S) {
3441 static std::unique_ptr<ARMOperand> CreateToken(StringRef Str, SMLoc S) {
3450 static std::unique_ptr<ARMOperand> CreateReg(unsigned RegNum, SMLoc S,
3451 SMLoc E) {
3461 unsigned ShiftReg, unsigned ShiftImm, SMLoc S,
3462 SMLoc E) {
3475 unsigned ShiftImm, SMLoc S, SMLoc E) {
3475 unsigned ShiftImm, SMLoc S, SMLoc E) {
3486 SMLoc S, SMLoc E) {
3486 SMLoc S, SMLoc E) {
3495 static std::unique_ptr<ARMOperand> CreateRotImm(unsigned Imm, SMLoc S,
3496 SMLoc E) {
3505 SMLoc S, SMLoc E) {
3505 SMLoc S, SMLoc E) {
3515 CreateConstantPoolImm(const MCExpr *Val, SMLoc S, SMLoc E) {
3515 CreateConstantPoolImm(const MCExpr *Val, SMLoc S, SMLoc E) {
3524 CreateBitfield(unsigned LSB, unsigned Width, SMLoc S, SMLoc E) {
3524 CreateBitfield(unsigned LSB, unsigned Width, SMLoc S, SMLoc E) {
3535 SMLoc StartLoc, SMLoc EndLoc) {
3535 SMLoc StartLoc, SMLoc EndLoc) {
3571 SMLoc S, SMLoc E) {
3571 SMLoc S, SMLoc E) {
3583 SMLoc S, SMLoc E) {
3583 SMLoc S, SMLoc E) {
3595 bool isDoubleSpaced, SMLoc S, SMLoc E) {
3595 bool isDoubleSpaced, SMLoc S, SMLoc E) {
3607 CreateVectorIndex(unsigned Idx, SMLoc S, SMLoc E, MCContext &Ctx) {
3607 CreateVectorIndex(unsigned Idx, SMLoc S, SMLoc E, MCContext &Ctx) {
3615 static std::unique_ptr<ARMOperand> CreateImm(const MCExpr *Val, SMLoc S,
3616 SMLoc E) {
3627 unsigned ShiftImm, unsigned Alignment, bool isNegative, SMLoc S,
3628 SMLoc E, SMLoc AlignmentLoc = SMLoc()) {
3628 SMLoc E, SMLoc AlignmentLoc = SMLoc()) {
3645 unsigned ShiftImm, SMLoc S, SMLoc E) {
3645 unsigned ShiftImm, SMLoc S, SMLoc E) {
3657 SMLoc S) {
3666 CreateInstSyncBarrierOpt(ARM_ISB::InstSyncBOpt Opt, SMLoc S) {
3675 CreateTraceSyncBarrierOpt(ARM_TSB::TraceSyncBOpt Opt, SMLoc S) {
3684 SMLoc S) {
3692 static std::unique_ptr<ARMOperand> CreateMSRMask(unsigned MMask, SMLoc S) {
3700 static std::unique_ptr<ARMOperand> CreateBankedReg(unsigned Reg, SMLoc S) {
3879 SMLoc &StartLoc, SMLoc &EndLoc) {
3879 SMLoc &StartLoc, SMLoc &EndLoc) {
3950 SMLoc S = Parser.getTok().getLoc();
3979 SMLoc EndLoc;
3992 SMLoc ImmLoc = Parser.getTok().getLoc();
4019 SMLoc L = Parser.getTok().getLoc();
4052 SMLoc RegStartLoc = Parser.getTok().getLoc();
4053 SMLoc RegEndLoc = Parser.getTok().getEndLoc();
4072 SMLoc SIdx = Parser.getTok().getLoc();
4085 SMLoc E = Parser.getTok().getEndLoc();
4149 SMLoc S = Parser.getTok().getLoc();
4169 SMLoc S = Parser.getTok().getLoc();
4191 SMLoc S = Parser.getTok().getLoc();
4210 SMLoc S = Parser.getTok().getLoc();
4218 SMLoc Loc = Parser.getTok().getLoc();
4233 SMLoc E = Parser.getTok().getEndLoc();
4286 SMLoc S = Parser.getTok().getLoc();
4288 SMLoc RegLoc = Parser.getTok().getLoc();
4331 SMLoc AfterMinusLoc = Parser.getTok().getLoc();
4425 SMLoc E = Parser.getTok().getEndLoc();
4442 parseVectorLane(VectorLaneTy &LaneKind, unsigned &Index, SMLoc &EndLoc) {
4461 SMLoc Loc = Parser.getTok().getLoc();
4498 SMLoc S = Parser.getTok().getLoc();
4503 SMLoc E = Parser.getTok().getEndLoc();
4560 SMLoc RegLoc = Parser.getTok().getLoc();
4585 SMLoc E;
4600 SMLoc AfterMinusLoc = Parser.getTok().getLoc();
4682 SMLoc LaneLoc = Parser.getTok().getLoc();
4707 SMLoc EndLoc = Parser.getTok().getLoc();
4753 SMLoc S = Parser.getTok().getLoc();
4793 SMLoc Loc = Parser.getTok().getLoc();
4824 SMLoc S = Parser.getTok().getLoc();
4843 SMLoc S = Parser.getTok().getLoc();
4861 SMLoc Loc = Parser.getTok().getLoc();
4895 SMLoc S = Parser.getTok().getLoc();
4930 SMLoc S = Parser.getTok().getLoc();
5028 SMLoc S = Parser.getTok().getLoc();
5071 SMLoc Loc = Parser.getTok().getLoc();
5072 SMLoc EndLoc;
5097 SMLoc S = Tok.getLoc();
5127 SMLoc S = Tok.getLoc();
5151 SMLoc ExLoc = Parser.getTok().getLoc();
5154 SMLoc EndLoc;
5198 SMLoc S = Tok.getLoc();
5213 SMLoc ExLoc = Parser.getTok().getLoc();
5216 SMLoc EndLoc;
5247 SMLoc S = Parser.getTok().getLoc();
5273 SMLoc Sx1, Ex1;
5327 SMLoc Sx2, Ex2;
5361 SMLoc S = Parser.getTok().getLoc();
5371 SMLoc E = Parser.getTok().getLoc();
5404 SMLoc EndLoc;
5439 SMLoc S = Tok.getLoc();
5451 SMLoc E = Parser.getTok().getEndLoc();
5492 SMLoc S = Tok.getLoc();
5502 SMLoc E;
5644 SMLoc S, E;
5689 SMLoc AlignmentLoc = Tok.getLoc();
5840 SMLoc Loc = Parser.getTok().getLoc();
5912 SMLoc S = Parser.getTok().getLoc();
5947 SMLoc Loc = Tok.getLoc();
5985 SMLoc S, E;
6039 E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
6065 E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
6096 E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
6108 E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
6749 SMLoc NameLoc, OperandVector &Operands) {
6802 SMLoc Loc = Mnemonic == "it" ? SMLoc::getFromPointer(NameLoc.getPointer() + 2) :
6802 SMLoc Loc = Mnemonic == "it" ? SMLoc::getFromPointer(NameLoc.getPointer() + 2) :
6803 Mnemonic == "vpt" ? SMLoc::getFromPointer(NameLoc.getPointer() + 3) :
6804 SMLoc::getFromPointer(NameLoc.getPointer() + 4);
6859 SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size());
6859 SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size());
6866 SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size() +
6866 SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size() +
6883 SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size() +
6883 SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size() +
6912 SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Start);
6912 SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Start);
6921 SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Start);
6921 SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Start);
6973 SMLoc MLoc = SMLoc::getFromPointer(NameLoc.getPointer());
6973 SMLoc MLoc = SMLoc::getFromPointer(NameLoc.getPointer());
6974 SMLoc PLoc = SMLoc::getFromPointer(NameLoc.getPointer() +
6974 SMLoc PLoc = SMLoc::getFromPointer(NameLoc.getPointer() +
6988 SMLoc MLoc = SMLoc::getFromPointer(NameLoc.getPointer());
6988 SMLoc MLoc = SMLoc::getFromPointer(NameLoc.getPointer());
6989 SMLoc PLoc = SMLoc::getFromPointer(NameLoc.getPointer() +
6989 SMLoc PLoc = SMLoc::getFromPointer(NameLoc.getPointer() +
7002 SMLoc MLoc = SMLoc::getFromPointer(NameLoc.getPointer());
7002 SMLoc MLoc = SMLoc::getFromPointer(NameLoc.getPointer());
7028 SMLoc MLoc = SMLoc::getFromPointer(NameLoc.getPointer());
7028 SMLoc MLoc = SMLoc::getFromPointer(NameLoc.getPointer());
7037 SMLoc PLoc = SMLoc::getFromPointer(NameLoc.getPointer() +
7037 SMLoc PLoc = SMLoc::getFromPointer(NameLoc.getPointer() +
7299 SMLoc Loc = Operands[0]->getStartLoc();
7312 SMLoc CondLoc;
7359 SMLoc PredLoc;
10409 bool ARMAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
10579 bool ARMAsmParser::parseLiteralValues(unsigned Size, SMLoc L) {
10592 bool ARMAsmParser::parseDirectiveThumb(SMLoc L) {
10606 bool ARMAsmParser::parseDirectiveARM(SMLoc L) {
10632 bool ARMAsmParser::parseDirectiveThumbFunc(SMLoc L) {
10664 bool ARMAsmParser::parseDirectiveSyntax(SMLoc L) {
10688 bool ARMAsmParser::parseDirectiveCode(SMLoc L) {
10724 bool ARMAsmParser::parseDirectiveReq(StringRef Name, SMLoc L) {
10728 SMLoc SRegLoc, ERegLoc;
10744 bool ARMAsmParser::parseDirectiveUnreq(SMLoc L) {
10759 void ARMAsmParser::FixModeAfterArchChange(bool WasThumb, SMLoc Loc) {
10783 bool ARMAsmParser::parseDirectiveArch(SMLoc L) {
10804 bool ARMAsmParser::parseDirectiveEabiAttr(SMLoc L) {
10807 SMLoc TagLoc;
10854 SMLoc ValueExprLoc = Parser.getTok().getLoc();
10893 bool ARMAsmParser::parseDirectiveCPU(SMLoc L) {
10913 bool ARMAsmParser::parseDirectiveFPU(SMLoc L) {
10914 SMLoc FPUNameLoc = getTok().getLoc();
10933 bool ARMAsmParser::parseDirectiveFnStart(SMLoc L) {
10955 bool ARMAsmParser::parseDirectiveFnEnd(SMLoc L) {
10972 bool ARMAsmParser::parseDirectiveCantUnwind(SMLoc L) {
10999 bool ARMAsmParser::parseDirectivePersonality(SMLoc L) {
11041 bool ARMAsmParser::parseDirectiveHandlerData(SMLoc L) {
11062 bool ARMAsmParser::parseDirectiveSetFP(SMLoc L) {
11071 SMLoc FPRegLoc = Parser.getTok().getLoc();
11079 SMLoc SPRegLoc = Parser.getTok().getLoc();
11098 SMLoc ExLoc = Parser.getTok().getLoc();
11099 SMLoc EndLoc;
11118 bool ARMAsmParser::parseDirectivePad(SMLoc L) {
11133 SMLoc ExLoc = Parser.getTok().getLoc();
11134 SMLoc EndLoc;
11152 bool ARMAsmParser::parseDirectiveRegSave(SMLoc L, bool IsVector) {
11180 bool ARMAsmParser::parseDirectiveInst(SMLoc Loc, char Suffix) {
11246 bool ARMAsmParser::parseDirectiveLtorg(SMLoc L) {
11253 bool ARMAsmParser::parseDirectiveEven(SMLoc L) {
11275 bool ARMAsmParser::parseDirectivePersonalityIndex(SMLoc L) {
11280 SMLoc IndexLoc = Parser.getTok().getLoc();
11321 bool ARMAsmParser::parseDirectiveUnwindRaw(SMLoc L) {
11325 SMLoc OffsetLoc = getLexer().getLoc();
11345 SMLoc OpcodeLoc = getLexer().getLoc();
11361 SMLoc OpcodeLoc = getLexer().getLoc();
11373 bool ARMAsmParser::parseDirectiveTLSDescSeq(SMLoc L) {
11394 bool ARMAsmParser::parseDirectiveMovSP(SMLoc L) {
11401 SMLoc SPRegLoc = Parser.getTok().getLoc();
11414 SMLoc OffsetLoc = Parser.getTok().getLoc();
11438 bool ARMAsmParser::parseDirectiveObjectArch(SMLoc L) {
11444 SMLoc ArchLoc = Parser.getTok().getLoc();
11460 bool ARMAsmParser::parseDirectiveAlign(SMLoc L) {
11478 bool ARMAsmParser::parseDirectiveThumbSet(SMLoc L) {
11541 SMLoc IDLoc, OperandVector &Operands) {
11563 SMLoc OperandLoc =
11678 SMLoc EndLoc = ((ARMOperand &)*Operands.back()).getEndLoc();
11694 SMLoc IDLoc, OperandVector &Operands) {
11717 bool ARMAsmParser::parseDirectiveArchExtension(SMLoc L) {
11759 SMLoc ExtLoc = Parser.getTok().getLoc();
lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp 468 SMLoc Loc) override {
556 void EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override {
597 explicit ElfMappingSymbolInfo(SMLoc Loc, MCFragment *F, uint64_t O)
604 SMLoc Loc;
656 void EmitMappingSymbol(StringRef Name, SMLoc Loc, MCFragment *F,
lib/Target/ARM/MCTargetDesc/ARMTargetStreamer.cpp 36 const MCExpr *ARMTargetStreamer::addConstantPoolEntry(const MCExpr *Expr, SMLoc Loc) {
lib/Target/AVR/AsmParser/AVRAsmParser.cpp 50 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
55 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
55 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
58 SMLoc NameLoc, OperandVector &Operands) override;
81 bool emit(MCInst &Instruction, SMLoc const &Loc, MCStreamer &Out) const;
82 bool invalidOperand(SMLoc const &Loc, OperandVector const &Operands,
84 bool missingFeature(SMLoc const &Loc, uint64_t const &ErrorInfo);
86 bool parseLiteralValues(unsigned SizeInBytes, SMLoc L);
108 AVROperand(StringRef Tok, SMLoc const &S)
110 AVROperand(unsigned Reg, SMLoc const &S, SMLoc const &E)
110 AVROperand(unsigned Reg, SMLoc const &S, SMLoc const &E)
112 AVROperand(MCExpr const *Imm, SMLoc const &S, SMLoc const &E)
112 AVROperand(MCExpr const *Imm, SMLoc const &S, SMLoc const &E)
114 AVROperand(unsigned Reg, MCExpr const *Imm, SMLoc const &S, SMLoc const &E)
114 AVROperand(unsigned Reg, MCExpr const *Imm, SMLoc const &S, SMLoc const &E)
126 SMLoc Start, End;
201 static std::unique_ptr<AVROperand> CreateToken(StringRef Str, SMLoc S) {
205 static std::unique_ptr<AVROperand> CreateReg(unsigned RegNum, SMLoc S,
206 SMLoc E) {
210 static std::unique_ptr<AVROperand> CreateImm(const MCExpr *Val, SMLoc S,
211 SMLoc E) {
216 CreateMemri(unsigned RegNum, const MCExpr *Val, SMLoc S, SMLoc E) {
216 CreateMemri(unsigned RegNum, const MCExpr *Val, SMLoc S, SMLoc E) {
240 SMLoc getStartLoc() const { return Start; }
241 SMLoc getEndLoc() const { return End; }
277 bool AVRAsmParser::invalidOperand(SMLoc const &Loc,
280 SMLoc ErrorLoc = Loc;
303 bool AVRAsmParser::missingFeature(llvm::SMLoc const &Loc,
308 bool AVRAsmParser::emit(MCInst &Inst, SMLoc const &Loc, MCStreamer &Out) const {
315 bool AVRAsmParser::MatchAndEmitInstruction(SMLoc Loc, unsigned &Opcode,
396 SMLoc S = Parser.getTok().getLoc();
414 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
414 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
423 SMLoc S = Parser.getTok().getLoc();
497 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
497 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
552 SMLoc E, S;
563 S = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
572 E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
580 bool AVRAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
581 SMLoc &EndLoc) {
598 StringRef Mnemonic, SMLoc NameLoc,
615 SMLoc Loc = getLexer().getLoc();
622 SMLoc Loc = getLexer().getLoc();
643 bool AVRAsmParser::parseLiteralValues(unsigned SizeInBytes, SMLoc L) {
lib/Target/AVR/MCTargetDesc/AVRMCELFStreamer.cpp 24 const MCSymbol *Sym, unsigned SizeInBytes, SMLoc Loc,
lib/Target/AVR/MCTargetDesc/AVRMCELFStreamer.h 45 const MCSymbol *Sym, unsigned SizeInBytes, SMLoc Loc = SMLoc(),
lib/Target/BPF/AsmParser/BPFAsmParser.cpp 32 SMLoc getLoc() const { return getParser().getTok().getLoc(); }
36 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
41 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
41 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
44 SMLoc NameLoc, OperandVector &Operands) override;
95 SMLoc StartLoc, EndLoc;
142 SMLoc getStartLoc() const override { return StartLoc; }
144 SMLoc getEndLoc() const override { return EndLoc; }
196 static std::unique_ptr<BPFOperand> createToken(StringRef Str, SMLoc S) {
204 static std::unique_ptr<BPFOperand> createReg(unsigned RegNo, SMLoc S,
205 SMLoc E) {
213 static std::unique_ptr<BPFOperand> createImm(const MCExpr *Val, SMLoc S,
214 SMLoc E) {
283 bool BPFAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
288 SMLoc ErrorLoc;
323 bool BPFAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
324 SMLoc &EndLoc) {
341 SMLoc S = getLoc();
406 SMLoc S = getLoc();
407 SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
407 SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
439 SMLoc S = getLoc();
444 SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
444 SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
453 SMLoc NameLoc, OperandVector &Operands) {
458 SMLoc E = SMLoc::getFromPointer(NameLoc.getPointer() - 1);
458 SMLoc E = SMLoc::getFromPointer(NameLoc.getPointer() - 1);
476 SMLoc Loc = getLexer().getLoc();
482 SMLoc Loc = getLexer().getLoc();
lib/Target/Hexagon/AsmParser/HexagonAsmParser.cpp 114 void Warning(SMLoc L, const Twine &Msg) { Parser.Warning(L, Msg); }
115 bool Error(SMLoc L, const Twine &Msg) { return Parser.Error(L, Msg); }
116 bool ParseDirectiveFalign(unsigned Size, SMLoc L);
118 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
118 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
119 bool ParseDirectiveSubsection(SMLoc L);
120 bool ParseDirectiveComm(bool IsLocal, SMLoc L);
124 bool handleNoncontigiousRegister(bool Contigious, SMLoc &Loc);
125 bool finishBundle(SMLoc IDLoc, MCStreamer &Out);
127 bool matchOneInstruction(MCInst &MCB, SMLoc IDLoc,
131 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
138 bool OutOfRange(SMLoc IDLoc, long long Val, long long Max);
140 SMLoc IDLoc);
181 SMLoc NameLoc, OperandVector &Operands) override {
197 SMLoc StartLoc, EndLoc;
245 SMLoc getStartLoc() const override { return StartLoc; }
248 SMLoc getEndLoc() const override { return EndLoc; }
419 StringRef Str, SMLoc S) {
429 CreateReg(MCContext &Context, unsigned RegNum, SMLoc S, SMLoc E) {
429 CreateReg(MCContext &Context, unsigned RegNum, SMLoc S, SMLoc E) {
438 CreateImm(MCContext &Context, const MCExpr *Val, SMLoc S, SMLoc E) {
438 CreateImm(MCContext &Context, const MCExpr *Val, SMLoc S, SMLoc E) {
464 bool HexagonAsmParser::finishBundle(SMLoc IDLoc, MCStreamer &Out) {
508 auto IDLoc = Parser.getTok().getLoc();
548 bool HexagonAsmParser::matchOneInstruction(MCInst &MCI, SMLoc IDLoc,
582 SMLoc ErrorLoc = IDLoc;
606 bool HexagonAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
666 bool HexagonAsmParser::ParseDirectiveSubsection(SMLoc L) {
693 bool HexagonAsmParser::ParseDirectiveFalign(unsigned Size, SMLoc L) {
700 SMLoc ExprLoc = L;
728 bool HexagonAsmParser::ParseDirectiveComm(bool IsLocal, SMLoc Loc) {
745 SMLoc SizeLoc = getLexer().getLoc();
750 SMLoc ByteAlignmentLoc;
764 SMLoc AccessAlignmentLoc;
848 SMLoc Loc = Token.getLoc();
865 SMLoc Begin;
866 SMLoc End;
950 SMLoc &Loc) {
960 bool HexagonAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
961 SMLoc &EndLoc) {
1073 SMLoc Loc = Lexer.getLoc();
1080 SMLoc Loc = Parser.getLexer().getLoc();
1140 SMLoc ExprLoc = Lexer.getLoc();
1270 bool HexagonAsmParser::OutOfRange(SMLoc IDLoc, long long Val, long long Max) {
1283 SMLoc IDLoc) {
lib/Target/Hexagon/MCTargetDesc/HexagonMCChecker.cpp 715 void HexagonMCChecker::reportError(SMLoc Loc, Twine const &Msg) {
720 void HexagonMCChecker::reportNote(SMLoc Loc, llvm::Twine const &Msg) {
lib/Target/Hexagon/MCTargetDesc/HexagonMCChecker.h 120 void reportError(SMLoc Loc, Twine const &Msg);
121 void reportNote(SMLoc Loc, Twine const &Msg);
lib/Target/Hexagon/MCTargetDesc/HexagonShuffler.cpp 227 SMLoc RestrictLoc;
258 SMLoc RestrictLoc;
lib/Target/Hexagon/MCTargetDesc/HexagonShuffler.h 154 SMLoc Loc;
156 std::vector<std::pair<SMLoc, std::string>> AppliedRestrictions;
lib/Target/Lanai/AsmParser/LanaiAsmParser.cpp 59 StringRef splitMnemonic(StringRef Name, SMLoc NameLoc,
67 SMLoc NameLoc, OperandVector &Operands) override;
69 bool ParseRegister(unsigned &RegNum, SMLoc &StartLoc, SMLoc &EndLoc) override;
69 bool ParseRegister(unsigned &RegNum, SMLoc &StartLoc, SMLoc &EndLoc) override;
71 bool MatchAndEmitInstruction(SMLoc IdLoc, unsigned &Opcode,
113 SMLoc StartLoc, EndLoc;
149 SMLoc getStartLoc() const override { return StartLoc; }
152 SMLoc getEndLoc() const override { return EndLoc; }
583 static std::unique_ptr<LanaiOperand> CreateToken(StringRef Str, SMLoc Start) {
592 static std::unique_ptr<LanaiOperand> createReg(unsigned RegNum, SMLoc Start,
593 SMLoc End) {
602 SMLoc Start, SMLoc End) {
602 SMLoc Start, SMLoc End) {
650 bool LanaiAsmParser::MatchAndEmitInstruction(SMLoc IdLoc, unsigned &Opcode,
656 SMLoc ErrorLoc;
691 SMLoc Start = Parser.getTok().getLoc();
692 SMLoc End = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
692 SMLoc End = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
708 bool LanaiAsmParser::ParseRegister(unsigned &RegNum, SMLoc &StartLoc,
709 SMLoc &EndLoc) {
720 SMLoc Start = Parser.getTok().getLoc();
721 SMLoc End = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
721 SMLoc End = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
765 End = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
778 SMLoc Start = Parser.getTok().getLoc();
779 SMLoc End = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
779 SMLoc End = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
952 SMLoc Start = Parser.getTok().getLoc();
953 SMLoc End =
954 SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1035 StringRef LanaiAsmParser::splitMnemonic(StringRef Name, SMLoc NameLoc,
1160 StringRef Name, SMLoc NameLoc,
lib/Target/MSP430/AsmParser/MSP430AsmParser.cpp 43 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
48 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
48 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
51 SMLoc NameLoc, OperandVector &Operands) override;
60 SMLoc NameLoc, OperandVector &Operands);
64 bool ParseLiteralValues(unsigned Size, SMLoc L);
112 SMLoc Start, End;
115 MSP430Operand(StringRef Tok, SMLoc const &S)
117 MSP430Operand(KindTy Kind, unsigned Reg, SMLoc const &S, SMLoc const &E)
117 MSP430Operand(KindTy Kind, unsigned Reg, SMLoc const &S, SMLoc const &E)
119 MSP430Operand(MCExpr const *Imm, SMLoc const &S, SMLoc const &E)
119 MSP430Operand(MCExpr const *Imm, SMLoc const &S, SMLoc const &E)
121 MSP430Operand(unsigned Reg, MCExpr const *Expr, SMLoc const &S, SMLoc const &E)
121 MSP430Operand(unsigned Reg, MCExpr const *Expr, SMLoc const &S, SMLoc const &E)
193 static std::unique_ptr<MSP430Operand> CreateToken(StringRef Str, SMLoc S) {
197 static std::unique_ptr<MSP430Operand> CreateReg(unsigned RegNum, SMLoc S,
198 SMLoc E) {
202 static std::unique_ptr<MSP430Operand> CreateImm(const MCExpr *Val, SMLoc S,
203 SMLoc E) {
209 SMLoc S, SMLoc E) {
209 SMLoc S, SMLoc E) {
213 static std::unique_ptr<MSP430Operand> CreateIndReg(unsigned RegNum, SMLoc S,
214 SMLoc E) {
218 static std::unique_ptr<MSP430Operand> CreatePostIndReg(unsigned RegNum, SMLoc S,
219 SMLoc E) {
223 SMLoc getStartLoc() const { return Start; }
224 SMLoc getEndLoc() const { return End; }
252 bool MSP430AsmParser::MatchAndEmitInstruction(SMLoc Loc, unsigned &Opcode,
269 SMLoc ErrorLoc = Loc;
289 bool MSP430AsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
290 SMLoc &EndLoc) {
312 StringRef Name, SMLoc NameLoc,
351 SMLoc ExprLoc = getLexer().getLoc();
364 SMLoc Loc = getLexer().getLoc();
374 StringRef Name, SMLoc NameLoc,
402 SMLoc Loc = getLexer().getLoc();
441 SMLoc StartLoc, EndLoc;
451 SMLoc StartLoc = getParser().getTok().getLoc();
456 SMLoc EndLoc = getParser().getTok().getLoc();
460 SMLoc RegStartLoc;
476 SMLoc StartLoc = getParser().getTok().getLoc();
480 SMLoc EndLoc = getParser().getTok().getLoc();
489 SMLoc StartLoc = getParser().getTok().getLoc();
492 SMLoc RegStartLoc, EndLoc;
509 SMLoc StartLoc = getParser().getTok().getLoc();
513 SMLoc EndLoc = getParser().getTok().getLoc();
521 bool MSP430AsmParser::ParseLiteralValues(unsigned Size, SMLoc L) {
lib/Target/Mips/AsmParser/MipsAsmParser.cpp 172 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
178 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
178 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
187 SMLoc NameLoc, OperandVector &Operands) override;
194 StringRef Identifier, SMLoc S);
197 SMLoc S);
199 SMLoc S);
217 MacroExpanderResultTy tryExpandInstruction(MCInst &Inst, SMLoc IDLoc,
221 bool expandJalWithRegs(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
225 bool Is32BitImm, bool IsAddress, SMLoc IDLoc,
229 unsigned SrcReg, bool Is32BitSym, SMLoc IDLoc,
232 bool emitPartialAddress(MipsTargetStreamer &TOut, SMLoc IDLoc, MCSymbol *Sym);
234 bool expandLoadImm(MCInst &Inst, bool Is32BitImm, SMLoc IDLoc,
237 bool expandLoadSingleImmToGPR(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
239 bool expandLoadSingleImmToFPR(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
241 bool expandLoadDoubleImmToGPR(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
243 bool expandLoadDoubleImmToFPR(MCInst &Inst, bool Is64FPU, SMLoc IDLoc,
248 SMLoc IDLoc, MCStreamer &Out,
251 bool expandUncondBranchMMPseudo(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
254 void expandMemInst(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
257 bool expandLoadStoreMultiple(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
260 bool expandAliasImmediate(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
263 bool expandBranchImm(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
266 bool expandCondBranches(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
269 bool expandDivRem(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
273 bool expandTrunc(MCInst &Inst, bool IsDouble, bool Is64FPU, SMLoc IDLoc,
276 bool expandUlh(MCInst &Inst, bool Signed, SMLoc IDLoc, MCStreamer &Out,
279 bool expandUsh(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
282 bool expandUxw(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
285 bool expandSge(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
288 bool expandSgeImm(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
291 bool expandSgtImm(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
294 bool expandRotation(MCInst &Inst, SMLoc IDLoc,
296 bool expandRotationImm(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
298 bool expandDRotation(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
300 bool expandDRotationImm(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
303 bool expandAbs(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
306 bool expandMulImm(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
309 bool expandMulO(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
312 bool expandMulOU(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
315 bool expandDMULMacro(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
318 bool expandLoadStoreDMacro(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
321 bool expandStoreDM1Macro(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
324 bool expandSeq(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
327 bool expandSeqI(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
330 bool expandMXTRAlias(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
334 bool reportParseError(SMLoc Loc, Twine ErrorMsg);
343 bool parseDirectiveCpLoad(SMLoc Loc);
344 bool parseDirectiveCpLocal(SMLoc Loc);
345 bool parseDirectiveCpRestore(SMLoc Loc);
415 unsigned getATReg(SMLoc Loc);
419 bool processInstruction(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
689 void warnIfRegIndexIsAT(unsigned RegIndex, SMLoc Loc);
691 void warnIfNoMacro(SMLoc Loc);
845 SMLoc StartLoc, EndLoc;
851 SMLoc S, SMLoc E,
851 SMLoc S, SMLoc E,
1453 static std::unique_ptr<MipsOperand> CreateToken(StringRef Str, SMLoc S,
1467 SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1467 SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1476 SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1476 SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1484 SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1484 SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1492 SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1492 SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1500 SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1500 SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1508 SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1508 SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1516 SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1516 SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1524 SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1524 SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1529 CreateImm(const MCExpr *Val, SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1529 CreateImm(const MCExpr *Val, SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1538 CreateMem(std::unique_ptr<MipsOperand> Base, const MCExpr *Off, SMLoc S,
1539 SMLoc E, MipsAsmParser &Parser) {
1549 CreateRegList(SmallVectorImpl<unsigned> &Regs, SMLoc StartLoc, SMLoc EndLoc,
1549 CreateRegList(SmallVectorImpl<unsigned> &Regs, SMLoc StartLoc, SMLoc EndLoc,
1657 SMLoc getStartLoc() const override { return StartLoc; }
1659 SMLoc getEndLoc() const override { return EndLoc; }
1780 bool MipsAsmParser::processInstruction(MCInst &Inst, SMLoc IDLoc,
2304 MipsAsmParser::tryExpandInstruction(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
2551 bool MipsAsmParser::expandJalWithRegs(MCInst &Inst, SMLoc IDLoc,
2616 bool IsAddress, SMLoc IDLoc, MCStreamer &Out,
2778 bool MipsAsmParser::expandLoadImm(MCInst &Inst, bool Is32BitImm, SMLoc IDLoc,
2794 bool Is32BitAddress, SMLoc IDLoc,
2829 bool Is32BitSym, SMLoc IDLoc,
3203 bool MipsAsmParser::emitPartialAddress(MipsTargetStreamer &TOut, SMLoc IDLoc,
3277 bool MipsAsmParser::expandLoadSingleImmToGPR(MCInst &Inst, SMLoc IDLoc,
3293 bool MipsAsmParser::expandLoadSingleImmToFPR(MCInst &Inst, SMLoc IDLoc,
3347 bool MipsAsmParser::expandLoadDoubleImmToGPR(MCInst &Inst, SMLoc IDLoc,
3413 SMLoc IDLoc, MCStreamer &Out,
3485 bool MipsAsmParser::expandUncondBranchMMPseudo(MCInst &Inst, SMLoc IDLoc,
3530 bool MipsAsmParser::expandBranchImm(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
3596 void MipsAsmParser::expandMemInst(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
3715 bool MipsAsmParser::expandLoadStoreMultiple(MCInst &Inst, SMLoc IDLoc,
3744 bool MipsAsmParser::expandCondBranches(MCInst &Inst, SMLoc IDLoc,
4015 bool MipsAsmParser::expandDivRem(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
4187 SMLoc IDLoc, MCStreamer &Out,
4225 bool MipsAsmParser::expandUlh(MCInst &Inst, bool Signed, SMLoc IDLoc,
4277 bool MipsAsmParser::expandUsh(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
4328 bool MipsAsmParser::expandUxw(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
4383 bool MipsAsmParser::expandSge(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
4417 bool MipsAsmParser::expandSgeImm(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
4473 bool MipsAsmParser::expandSgtImm(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
4520 bool MipsAsmParser::expandAliasImmediate(MCInst &Inst, SMLoc IDLoc,
4627 bool MipsAsmParser::expandRotation(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
4689 bool MipsAsmParser::expandRotationImm(MCInst &Inst, SMLoc IDLoc,
4752 bool MipsAsmParser::expandDRotation(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
4814 bool MipsAsmParser::expandDRotationImm(MCInst &Inst, SMLoc IDLoc,
4909 bool MipsAsmParser::expandAbs(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
4925 bool MipsAsmParser::expandMulImm(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
4948 bool MipsAsmParser::expandMulO(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
4990 bool MipsAsmParser::expandMulOU(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
5026 bool MipsAsmParser::expandDMULMacro(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
5044 bool MipsAsmParser::expandLoadStoreDMacro(MCInst &Inst, SMLoc IDLoc,
5092 bool MipsAsmParser::expandStoreDM1Macro(MCInst &Inst, SMLoc IDLoc,
5129 bool MipsAsmParser::expandSeq(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
5155 bool MipsAsmParser::expandSeqI(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
5345 bool MipsAsmParser::expandMXTRAlias(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out,
5570 static SMLoc RefineErrorLoc(const SMLoc Loc, const OperandVector &Operands,
5570 static SMLoc RefineErrorLoc(const SMLoc Loc, const OperandVector &Operands,
5573 SMLoc ErrorLoc = Operands[ErrorInfo]->getStartLoc();
5581 bool MipsAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
5599 SMLoc ErrorLoc = IDLoc;
5758 SMLoc ErrorStart = Operands[3]->getStartLoc();
5759 SMLoc ErrorEnd = Operands[4]->getEndLoc();
5764 SMLoc ErrorStart = Operands[3]->getStartLoc();
5765 SMLoc ErrorEnd = Operands[4]->getEndLoc();
5770 SMLoc ErrorStart = Operands[3]->getStartLoc();
5771 SMLoc ErrorEnd = Operands[4]->getEndLoc();
5780 void MipsAsmParser::warnIfRegIndexIsAT(unsigned RegIndex, SMLoc Loc) {
5786 void MipsAsmParser::warnIfNoMacro(SMLoc Loc) {
5974 unsigned MipsAsmParser::getATReg(SMLoc Loc) {
6010 SMLoc S = Parser.getTok().getLoc();
6025 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
6025 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
6038 SMLoc S = Parser.getTok().getLoc(); // Start location of the operand.
6042 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
6042 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
6071 bool MipsAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
6072 SMLoc &EndLoc) {
6098 SMLoc S;
6110 SMLoc S;
6129 SMLoc E =
6130 SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
6135 SMLoc E =
6136 SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
6214 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
6214 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
6247 SMLoc S = Parser.getTok().getLoc();
6285 SMLoc S) {
6347 const AsmToken &Token, SMLoc S) {
6375 MipsAsmParser::matchAnyRegisterWithoutDollar(OperandVector &Operands, SMLoc S) {
6387 SMLoc S = Token.getLoc();
6413 SMLoc S = getLexer().getLoc();
6439 SMLoc S = Parser.getTok().getLoc();
6451 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
6451 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
6469 SMLoc S = Parser.getTok().getLoc();
6471 SMLoc E = getLexer().getLoc();
6537 SMLoc E = Parser.getTok().getLoc();
6555 SMLoc Loc = getLexer().getLoc();
6559 SMLoc Loc = getLexer().getLoc();
6583 SMLoc Loc = getLexer().getLoc();
6587 SMLoc Loc = getLexer().getLoc();
6601 SMLoc NameLoc, OperandVector &Operands) {
6621 SMLoc Loc = getLexer().getLoc();
6632 SMLoc Loc = getLexer().getLoc();
6645 SMLoc Loc = getLexer().getLoc();
6655 SMLoc Loc = getLexer().getLoc();
6659 bool MipsAsmParser::reportParseError(SMLoc Loc, Twine ErrorMsg) {
7020 SMLoc Loc = getLexer().getLoc();
7269 SMLoc Loc = getLexer().getLoc();
7285 bool MipsAsmParser::parseDirectiveCpLoad(SMLoc Loc) {
7317 bool MipsAsmParser::parseDirectiveCpLocal(SMLoc Loc) {
7351 bool MipsAsmParser::parseDirectiveCpRestore(SMLoc Loc) {
7425 SMLoc ExprLoc = getLexer().getLoc();
7497 SMLoc Loc = Tok.getLoc();
7843 SMLoc L = Lexer.getLoc();
lib/Target/Mips/MCTargetDesc/MipsELFStreamer.cpp 88 void MipsELFStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
100 SMLoc Loc) {
lib/Target/Mips/MCTargetDesc/MipsELFStreamer.h 49 void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
59 void EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override;
lib/Target/Mips/MCTargetDesc/MipsTargetStreamer.cpp 136 int Offset, function_ref<unsigned()> GetATReg, SMLoc IDLoc,
171 void MipsTargetStreamer::emitR(unsigned Opcode, unsigned Reg0, SMLoc IDLoc,
181 SMLoc IDLoc, const MCSubtargetInfo *STI) {
191 SMLoc IDLoc, const MCSubtargetInfo *STI) {
196 SMLoc IDLoc, const MCSubtargetInfo *STI) {
201 SMLoc IDLoc, const MCSubtargetInfo *STI) {
211 MCOperand Op2, SMLoc IDLoc,
223 unsigned Reg2, SMLoc IDLoc,
229 unsigned Reg2, MCOperand Op3, SMLoc IDLoc,
242 int16_t Imm, SMLoc IDLoc,
249 int16_t Imm2, SMLoc IDLoc,
270 int16_t ShiftAmount, SMLoc IDLoc,
280 void MipsTargetStreamer::emitEmptyDelaySlot(bool hasShortDelaySlot, SMLoc IDLoc,
288 void MipsTargetStreamer::emitNop(SMLoc IDLoc, const MCSubtargetInfo *STI) {
296 void MipsTargetStreamer::emitGPRestore(int Offset, SMLoc IDLoc,
304 function_ref<unsigned()> GetATReg, SMLoc IDLoc,
340 unsigned ATReg, SMLoc IDLoc,
371 unsigned TmpReg, SMLoc IDLoc,
701 int Offset, function_ref<unsigned()> GetATReg, SMLoc IDLoc,
1209 int Offset, function_ref<unsigned()> GetATReg, SMLoc IDLoc,
lib/Target/Mips/MipsTargetStreamer.h 97 SMLoc IDLoc, const MCSubtargetInfo *STI);
119 void emitR(unsigned Opcode, unsigned Reg0, SMLoc IDLoc,
121 void emitII(unsigned Opcode, int16_t Imm1, int16_t Imm2, SMLoc IDLoc,
123 void emitRX(unsigned Opcode, unsigned Reg0, MCOperand Op1, SMLoc IDLoc,
125 void emitRI(unsigned Opcode, unsigned Reg0, int32_t Imm, SMLoc IDLoc,
127 void emitRR(unsigned Opcode, unsigned Reg0, unsigned Reg1, SMLoc IDLoc,
130 SMLoc IDLoc, const MCSubtargetInfo *STI);
132 SMLoc IDLoc, const MCSubtargetInfo *STI);
134 MCOperand Op3, SMLoc IDLoc, const MCSubtargetInfo *STI);
136 SMLoc IDLoc, const MCSubtargetInfo *STI);
138 int16_t Imm1, int16_t Imm2, SMLoc IDLoc,
143 SMLoc IDLoc, const MCSubtargetInfo *STI);
144 void emitEmptyDelaySlot(bool hasShortDelaySlot, SMLoc IDLoc,
146 void emitNop(SMLoc IDLoc, const MCSubtargetInfo *STI);
157 function_ref<unsigned()> GetATReg, SMLoc IDLoc,
161 unsigned ATReg, SMLoc IDLoc,
164 int64_t Offset, unsigned TmpReg, SMLoc IDLoc,
166 void emitGPRestore(int Offset, SMLoc IDLoc, const MCSubtargetInfo *STI);
287 SMLoc IDLoc, const MCSubtargetInfo *STI) override;
351 SMLoc IDLoc, const MCSubtargetInfo *STI) override;
lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp 104 void Warning(SMLoc L, const Twine &Msg) { getParser().Warning(L, Msg); }
111 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
111 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
123 bool ParseDirectiveMachine(SMLoc L);
124 bool ParseDarwinDirectiveMachine(SMLoc L);
125 bool ParseDirectiveAbiVersion(SMLoc L);
126 bool ParseDirectiveLocalEntry(SMLoc L);
128 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
157 SMLoc NameLoc, OperandVector &Operands) override;
180 SMLoc StartLoc, EndLoc;
237 SMLoc getStartLoc() const override { return StartLoc; }
240 SMLoc getEndLoc() const override { return EndLoc; }
580 static std::unique_ptr<PPCOperand> CreateToken(StringRef Str, SMLoc S,
592 CreateTokenWithStringCopy(StringRef Str, SMLoc S, bool IsPPC64) {
609 static std::unique_ptr<PPCOperand> CreateImm(int64_t Val, SMLoc S, SMLoc E,
609 static std::unique_ptr<PPCOperand> CreateImm(int64_t Val, SMLoc S, SMLoc E,
619 static std::unique_ptr<PPCOperand> CreateExpr(const MCExpr *Val, SMLoc S,
620 SMLoc E, bool IsPPC64) {
631 CreateTLSReg(const MCSymbolRefExpr *Sym, SMLoc S, SMLoc E, bool IsPPC64) {
631 CreateTLSReg(const MCSymbolRefExpr *Sym, SMLoc S, SMLoc E, bool IsPPC64) {
641 CreateContextImm(int64_t Val, SMLoc S, SMLoc E, bool IsPPC64) {
641 CreateContextImm(int64_t Val, SMLoc S, SMLoc E, bool IsPPC64) {
651 CreateFromMCExpr(const MCExpr *Val, SMLoc S, SMLoc E, bool IsPPC64) {
651 CreateFromMCExpr(const MCExpr *Val, SMLoc S, SMLoc E, bool IsPPC64) {
1134 bool PPCAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
1157 SMLoc ErrorLoc = IDLoc;
1212 ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) {
1212 ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) {
1440 SMLoc S = Parser.getTok().getLoc();
1441 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1441 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1557 SMLoc NameLoc, OperandVector &Operands) {
1582 SMLoc DotLoc = SMLoc::getFromPointer(NameLoc.getPointer() + Dot);
1582 SMLoc DotLoc = SMLoc::getFromPointer(NameLoc.getPointer() + Dot);
1652 SMLoc ExprLoc = getParser().getTok().getLoc();
1692 bool PPCAsmParser::ParseDirectiveMachine(SMLoc L) {
1723 bool PPCAsmParser::ParseDarwinDirectiveMachine(SMLoc L) {
1748 bool PPCAsmParser::ParseDirectiveAbiVersion(SMLoc L) {
1765 bool PPCAsmParser::ParseDirectiveLocalEntry(SMLoc L) {
lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp 50 SMLoc getLoc() const { return getParser().getTok().getLoc(); }
65 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
70 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
70 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
73 SMLoc NameLoc, OperandVector &Operands) override;
89 unsigned SecondOpcode, SMLoc IDLoc, MCStreamer &Out);
92 void emitLoadLocalAddress(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out);
95 void emitLoadAddress(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out);
99 void emitLoadTLSIEAddress(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out);
103 void emitLoadTLSGDAddress(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out);
106 void emitLoadStoreSymbol(MCInst &Inst, unsigned Opcode, SMLoc IDLoc,
119 bool processInstruction(MCInst &Inst, SMLoc IDLoc, OperandVector &Operands,
223 SMLoc StartLoc, EndLoc;
590 SMLoc getStartLoc() const override { return StartLoc; }
592 SMLoc getEndLoc() const override { return EndLoc; }
634 static std::unique_ptr<RISCVOperand> createToken(StringRef Str, SMLoc S,
644 static std::unique_ptr<RISCVOperand> createReg(unsigned RegNo, SMLoc S,
645 SMLoc E, bool IsRV64) {
654 static std::unique_ptr<RISCVOperand> createImm(const MCExpr *Val, SMLoc S,
655 SMLoc E, bool IsRV64) {
665 createSysReg(StringRef Str, SMLoc S, unsigned Encoding, bool IsRV64) {
774 SMLoc ErrorLoc = ((RISCVOperand &)*Operands[ErrorInfo]).getStartLoc();
778 bool RISCVAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
797 SMLoc ErrorLoc = IDLoc;
814 SMLoc ErrorLoc = IDLoc;
824 SMLoc ErrorLoc = ((RISCVOperand &)*Operands[ErrorInfo]).getStartLoc();
831 SMLoc ErrorLoc = ((RISCVOperand &)*Operands[ErrorInfo]).getStartLoc();
917 SMLoc ErrorLoc = ((RISCVOperand &)*Operands[ErrorInfo]).getStartLoc();
923 SMLoc ErrorLoc = ((RISCVOperand &)*Operands[ErrorInfo]).getStartLoc();
929 SMLoc ErrorLoc = ((RISCVOperand &)*Operands[ErrorInfo]).getStartLoc();
933 SMLoc ErrorLoc = ((RISCVOperand &)*Operands[ErrorInfo]).getStartLoc();
937 SMLoc ErrorLoc = ((RISCVOperand &)*Operands[ErrorInfo]).getStartLoc();
964 bool RISCVAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
965 SMLoc &EndLoc) {
981 SMLoc FirstS = getLoc();
1014 SMLoc S = getLoc();
1015 SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
1015 SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
1030 SMLoc S = getLoc();
1097 SMLoc S = getLoc();
1098 SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
1098 SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
1126 SMLoc S = getLoc();
1127 SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
1127 SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
1165 SMLoc S = getLoc();
1166 SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
1166 SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
1217 SMLoc S = getLoc();
1218 SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
1218 SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
1312 SMLoc ImmStart = getLoc();
1319 SMLoc ImmEnd = getLoc();
1384 StringRef Name, SMLoc NameLoc,
1426 SMLoc Loc = getLexer().getLoc();
1517 SMLoc StartLoc = Parser.getTok().getLoc();
1618 unsigned SecondOpcode, SMLoc IDLoc,
1643 void RISCVAsmParser::emitLoadLocalAddress(MCInst &Inst, SMLoc IDLoc,
1657 void RISCVAsmParser::emitLoadAddress(MCInst &Inst, SMLoc IDLoc,
1683 void RISCVAsmParser::emitLoadTLSIEAddress(MCInst &Inst, SMLoc IDLoc,
1698 void RISCVAsmParser::emitLoadTLSGDAddress(MCInst &Inst, SMLoc IDLoc,
1713 SMLoc IDLoc, MCStreamer &Out,
1736 SMLoc ErrorLoc = ((RISCVOperand &)*Operands[3]).getStartLoc();
1744 bool RISCVAsmParser::processInstruction(MCInst &Inst, SMLoc IDLoc,
lib/Target/Sparc/AsmParser/SparcAsmParser.cpp 66 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
70 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
70 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
72 SMLoc NameLoc, OperandVector &Operands) override;
99 bool matchSparcAsmModifiers(const MCExpr *&EVal, SMLoc &EndLoc);
105 bool expandSET(MCInst &Inst, SMLoc IDLoc,
223 SMLoc StartLoc, EndLoc;
311 SMLoc getStartLoc() const override {
315 SMLoc getEndLoc() const override {
378 static std::unique_ptr<SparcOperand> CreateToken(StringRef Str, SMLoc S) {
388 SMLoc S, SMLoc E) {
388 SMLoc S, SMLoc E) {
397 static std::unique_ptr<SparcOperand> CreateImm(const MCExpr *Val, SMLoc S,
398 SMLoc E) {
483 CreateMEMr(unsigned Base, SMLoc S, SMLoc E) {
483 CreateMEMr(unsigned Base, SMLoc S, SMLoc E) {
506 bool SparcAsmParser::expandSET(MCInst &Inst, SMLoc IDLoc,
580 bool SparcAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
613 SMLoc ErrorLoc = IDLoc;
631 bool SparcAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
632 SMLoc &EndLoc) {
654 StringRef Name, SMLoc NameLoc,
667 SMLoc Loc = getLexer().getLoc();
672 SMLoc Loc = getLexer().getLoc();
684 SMLoc Loc = getLexer().getLoc();
690 SMLoc Loc = getLexer().getLoc();
720 SMLoc S, E;
756 SMLoc S = Parser.getTok().getLoc();
770 SMLoc TagStart = getLexer().getLoc();
796 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
796 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
819 SMLoc S = Parser.getTok().getLoc();
829 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer()-1);
829 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer()-1);
872 SMLoc S = Parser.getTok().getLoc();
873 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
873 SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
887 E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
923 E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
939 E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1286 SMLoc &EndLoc) {
lib/Target/SystemZ/AsmParser/SystemZAsmParser.cpp 88 SMLoc StartLoc, EndLoc;
152 SystemZOperand(OperandKind kind, SMLoc startLoc, SMLoc endLoc)
152 SystemZOperand(OperandKind kind, SMLoc startLoc, SMLoc endLoc)
156 static std::unique_ptr<SystemZOperand> createInvalid(SMLoc StartLoc,
157 SMLoc EndLoc) {
161 static std::unique_ptr<SystemZOperand> createToken(StringRef Str, SMLoc Loc) {
169 createReg(RegisterKind Kind, unsigned Num, SMLoc StartLoc, SMLoc EndLoc) {
169 createReg(RegisterKind Kind, unsigned Num, SMLoc StartLoc, SMLoc EndLoc) {
177 createImm(const MCExpr *Expr, SMLoc StartLoc, SMLoc EndLoc) {
177 createImm(const MCExpr *Expr, SMLoc StartLoc, SMLoc EndLoc) {
186 unsigned LengthReg, SMLoc StartLoc, SMLoc EndLoc) {
186 unsigned LengthReg, SMLoc StartLoc, SMLoc EndLoc) {
202 SMLoc StartLoc, SMLoc EndLoc) {
202 SMLoc StartLoc, SMLoc EndLoc) {
285 SMLoc getStartLoc() const override { return StartLoc; }
286 SMLoc getEndLoc() const override { return EndLoc; }
405 SMLoc StartLoc, EndLoc;
424 bool ParseDirectiveInsn(SMLoc L);
451 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
451 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
453 SMLoc NameLoc, OperandVector &Operands) override;
454 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
779 SMLoc StartLoc = Parser.getTok().getLoc();
791 SMLoc EndLoc =
792 SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
898 SMLoc StartLoc = Parser.getTok().getLoc();
1007 SMLoc EndLoc =
1008 SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1026 bool SystemZAsmParser::ParseDirectiveInsn(SMLoc L) {
1031 SMLoc ErrorLoc = Parser.getTok().getLoc();
1055 SMLoc StartLoc = Parser.getTok().getLoc();
1077 SMLoc StartLoc = Parser.getTok().getLoc();
1083 SMLoc EndLoc =
1084 SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1126 bool SystemZAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
1127 SMLoc &EndLoc) {
1147 StringRef Name, SMLoc NameLoc,
1166 SMLoc Loc = getLexer().getLoc();
1213 SMLoc StartLoc = Parser.getTok().getLoc();
1228 SMLoc EndLoc =
1229 SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1241 bool SystemZAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
1273 SMLoc ErrorLoc = IDLoc;
1303 SMLoc StartLoc = Parser.getTok().getLoc();
1361 SMLoc EndLoc =
1362 SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp 45 SMLoc StartLoc, EndLoc;
75 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, TokOp T)
75 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, TokOp T)
77 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, IntOp I)
77 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, IntOp I)
79 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, FltOp F)
79 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, FltOp F)
81 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, SymOp S)
81 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, SymOp S)
83 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End)
83 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End)
108 SMLoc getStartLoc() const override { return StartLoc; }
109 SMLoc getEndLoc() const override { return EndLoc; }
213 bool ParseRegister(unsigned & /*RegNo*/, SMLoc & /*StartLoc*/,
214 SMLoc & /*EndLoc*/) override {
419 void addBlockTypeOperand(OperandVector &Operands, SMLoc NameLoc,
427 SMLoc NameLoc, OperandVector &Operands) override {
454 WebAssemblyOperand::Token, NameLoc, SMLoc::getFromPointer(Name.end()),
544 SMLoc End;
749 SMLoc End;
783 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned & /*Opcode*/,
818 SMLoc ErrorLoc = IDLoc;
lib/Target/X86/AsmParser/X86AsmParser.cpp 85 SMLoc consumeToken() {
87 SMLoc Result = Parser.getTok().getLoc();
804 bool Error(SMLoc L, const Twine &Msg, SMRange Range = None,
815 std::nullptr_t ErrorOperand(SMLoc Loc, StringRef Msg, SMRange R = SMRange()) {
820 std::unique_ptr<X86Operand> DefaultMemSIOperand(SMLoc Loc);
821 std::unique_ptr<X86Operand> DefaultMemDIOperand(SMLoc Loc);
834 bool ParseIntelDotOperator(IntelExprStateMachine &SM, SMLoc &End);
837 std::unique_ptr<X86Operand> ParseRoundingModeOp(SMLoc Start);
839 void RewriteIntelExpression(IntelExprStateMachine &SM, SMLoc Start,
840 SMLoc End);
841 bool ParseIntelExpression(IntelExprStateMachine &SM, SMLoc &End);
844 bool IsUnevaluatedOperand, SMLoc &End);
848 const SMLoc &StartLoc,
849 SMLoc &EndLoc);
856 unsigned IndexReg, unsigned Scale, SMLoc Start,
857 SMLoc End, unsigned Size, StringRef Identifier,
860 bool parseDirectiveEven(SMLoc L);
861 bool ParseDirectiveCode(StringRef IDVal, SMLoc L);
864 bool parseDirectiveFPOProc(SMLoc L);
865 bool parseDirectiveFPOSetFrame(SMLoc L);
866 bool parseDirectiveFPOPushReg(SMLoc L);
867 bool parseDirectiveFPOStackAlloc(SMLoc L);
868 bool parseDirectiveFPOStackAlign(SMLoc L);
869 bool parseDirectiveFPOEndPrologue(SMLoc L);
870 bool parseDirectiveFPOEndProc(SMLoc L);
871 bool parseDirectiveFPOData(SMLoc L);
875 bool parseDirectiveSEHPushReg(SMLoc);
876 bool parseDirectiveSEHSetFrame(SMLoc);
877 bool parseDirectiveSEHSaveReg(SMLoc);
878 bool parseDirectiveSEHSaveXMM(SMLoc);
879 bool parseDirectiveSEHPushFrame(SMLoc);
890 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
895 void MatchFPUWaitAlias(SMLoc IDLoc, X86Operand &Op, OperandVector &Operands,
898 bool ErrorMissingFeature(SMLoc IDLoc, const FeatureBitset &MissingFeatures,
901 bool MatchAndEmitATTInstruction(SMLoc IDLoc, unsigned &Opcode,
906 bool MatchAndEmitIntelInstruction(SMLoc IDLoc, unsigned &Opcode,
919 bool ParseZ(std::unique_ptr<X86Operand> &Z, const SMLoc &StartLoc);
981 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
981 bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
983 bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) override;
986 SMLoc NameLoc, OperandVector &Operands) override;
1089 SMLoc &StartLoc, SMLoc &EndLoc) {
1089 SMLoc &StartLoc, SMLoc &EndLoc) {
1217 std::unique_ptr<X86Operand> X86AsmParser::DefaultMemSIOperand(SMLoc Loc) {
1226 std::unique_ptr<X86Operand> X86AsmParser::DefaultMemDIOperand(SMLoc Loc) {
1283 SmallVector<std::pair<SMLoc, std::string>, 2> Warnings;
1365 unsigned Scale, SMLoc Start, SMLoc End, unsigned Size, StringRef Identifier,
1365 unsigned Scale, SMLoc Start, SMLoc End, unsigned Size, StringRef Identifier,
1434 bool X86AsmParser::ParseIntelExpression(IntelExprStateMachine &SM, SMLoc &End) {
1462 SMLoc IdentLoc = Tok.getLoc();
1516 SMLoc Loc = getTok().getLoc();
1588 SMLoc Start, SMLoc End) {
1588 SMLoc Start, SMLoc End) {
1589 SMLoc Loc = Start;
1596 Loc = SMLoc::getFromPointer(SymName.data() + SymName.size());
1623 SMLoc &End) {
1632 SMLoc Loc = Tok.getLoc();
1670 X86AsmParser::ParseRoundingModeOp(SMLoc Start) {
1674 const SMLoc consumedToken = consumeToken();
1693 SMLoc End = Tok.getEndLoc();
1710 bool X86AsmParser::ParseIntelDotOperator(IntelExprStateMachine &SM, SMLoc &End) {
1733 End = SMLoc::getFromPointer(DotDispStr.data());
1746 SMLoc OffsetOfLoc = Tok.getLoc();
1751 SMLoc Start = Tok.getLoc(), End;
1800 SMLoc Start = Tok.getLoc(), End;
1851 SMLoc Start, End;
1964 SMLoc Start = Parser.getTok().getLoc(), End;
1969 SMLoc L = Parser.getTok().getLoc();
1978 SMLoc Start = Parser.getTok().getLoc();
1987 SMLoc Loc = Parser.getTok().getLoc(), EndLoc;
2046 const SMLoc &StartLoc) {
2070 const SMLoc consumedToken = consumeToken();
2110 SMLoc StartLoc = Z ? consumeToken() : consumedToken;
2114 SMLoc RegLoc;
2152 const SMLoc &StartLoc,
2153 SMLoc &EndLoc) {
2155 SMLoc Loc;
2236 SMLoc BaseLoc = getLexer().getLoc();
2329 bool X86AsmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) {
2335 SMLoc StartLoc = Parser.getTok().getLoc();
2346 SMLoc NameLoc, OperandVector &Operands) {
2400 SMLoc NameEndLoc =
2695 SMLoc Loc = Op1.getEndLoc();
3045 bool X86AsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
3056 void X86AsmParser::MatchFPUWaitAlias(SMLoc IDLoc, X86Operand &Op,
3082 bool X86AsmParser::ErrorMissingFeature(SMLoc IDLoc,
3139 bool X86AsmParser::MatchAndEmitATTInstruction(SMLoc IDLoc, unsigned &Opcode,
3187 SMLoc ErrorLoc = ((X86Operand &)*Operands[ErrorInfo]).getStartLoc();
3345 bool X86AsmParser::MatchAndEmitIntelInstruction(SMLoc IDLoc, unsigned &Opcode,
3542 SMLoc ErrorLoc = ((X86Operand &)*Operands[ErrorInfo]).getStartLoc();
3617 bool X86AsmParser::parseDirectiveEven(SMLoc L) {
3635 bool X86AsmParser::ParseDirectiveCode(StringRef IDVal, SMLoc L) {
3673 bool X86AsmParser::parseDirectiveFPOProc(SMLoc L) {
3690 bool X86AsmParser::parseDirectiveFPOSetFrame(SMLoc L) {
3693 SMLoc DummyLoc;
3701 bool X86AsmParser::parseDirectiveFPOPushReg(SMLoc L) {
3704 SMLoc DummyLoc;
3712 bool X86AsmParser::parseDirectiveFPOStackAlloc(SMLoc L) {
3722 bool X86AsmParser::parseDirectiveFPOStackAlign(SMLoc L) {
3732 bool X86AsmParser::parseDirectiveFPOEndPrologue(SMLoc L) {
3740 bool X86AsmParser::parseDirectiveFPOEndProc(SMLoc L) {
3749 SMLoc startLoc = getLexer().getLoc();
3754 SMLoc endLoc;
3787 bool X86AsmParser::parseDirectiveSEHPushReg(SMLoc Loc) {
3800 bool X86AsmParser::parseDirectiveSEHSetFrame(SMLoc Loc) {
3820 bool X86AsmParser::parseDirectiveSEHSaveReg(SMLoc Loc) {
3840 bool X86AsmParser::parseDirectiveSEHSaveXMM(SMLoc Loc) {
3860 bool X86AsmParser::parseDirectiveSEHPushFrame(SMLoc Loc) {
3864 SMLoc startLoc = getLexer().getLoc();
lib/Target/X86/AsmParser/X86Operand.h 34 SMLoc StartLoc, EndLoc;
35 SMLoc OffsetOfLoc;
79 X86Operand(KindTy K, SMLoc Start, SMLoc End)
79 X86Operand(KindTy K, SMLoc Start, SMLoc End)
86 SMLoc getStartLoc() const override { return StartLoc; }
89 SMLoc getEndLoc() const override { return EndLoc; }
96 SMLoc getOffsetOfLoc() const override { return OffsetOfLoc; }
582 static std::unique_ptr<X86Operand> CreateToken(StringRef Str, SMLoc Loc) {
583 SMLoc EndLoc = SMLoc::getFromPointer(Loc.getPointer() + Str.size());
583 SMLoc EndLoc = SMLoc::getFromPointer(Loc.getPointer() + Str.size());
591 CreateReg(unsigned RegNo, SMLoc StartLoc, SMLoc EndLoc,
591 CreateReg(unsigned RegNo, SMLoc StartLoc, SMLoc EndLoc,
592 bool AddressOf = false, SMLoc OffsetOfLoc = SMLoc(),
604 CreateDXReg(SMLoc StartLoc, SMLoc EndLoc) {
604 CreateDXReg(SMLoc StartLoc, SMLoc EndLoc) {
609 CreatePrefix(unsigned Prefixes, SMLoc StartLoc, SMLoc EndLoc) {
609 CreatePrefix(unsigned Prefixes, SMLoc StartLoc, SMLoc EndLoc) {
616 SMLoc StartLoc, SMLoc EndLoc) {
616 SMLoc StartLoc, SMLoc EndLoc) {
624 CreateMem(unsigned ModeSize, const MCExpr *Disp, SMLoc StartLoc, SMLoc EndLoc,
624 CreateMem(unsigned ModeSize, const MCExpr *Disp, SMLoc StartLoc, SMLoc EndLoc,
645 unsigned BaseReg, unsigned IndexReg, unsigned Scale, SMLoc StartLoc,
646 SMLoc EndLoc, unsigned Size = 0, StringRef SymName = StringRef(),
lib/Target/X86/MCTargetDesc/X86ELFObjectWriter.cpp 91 static void checkIs32(MCContext &Ctx, SMLoc Loc, X86_64RelType Type) {
97 static unsigned getRelocType64(MCContext &Ctx, SMLoc Loc,
lib/Target/X86/MCTargetDesc/X86MCCodeEmitter.cpp 110 void EmitImmediate(const MCOperand &Disp, SMLoc Loc,
299 EmitImmediate(const MCOperand &DispOp, SMLoc Loc, unsigned Size,
lib/Target/X86/MCTargetDesc/X86TargetStreamer.h 22 SMLoc L = {}) = 0;
23 virtual bool emitFPOEndPrologue(SMLoc L = {}) = 0;
24 virtual bool emitFPOEndProc(SMLoc L = {}) = 0;
25 virtual bool emitFPOData(const MCSymbol *ProcSym, SMLoc L = {}) = 0;
26 virtual bool emitFPOPushReg(unsigned Reg, SMLoc L = {}) = 0;
27 virtual bool emitFPOStackAlloc(unsigned StackAlloc, SMLoc L = {}) = 0;
28 virtual bool emitFPOStackAlign(unsigned Align, SMLoc L = {}) = 0;
29 virtual bool emitFPOSetFrame(unsigned Reg, SMLoc L = {}) = 0;
lib/Target/X86/MCTargetDesc/X86WinCOFFStreamer.cpp 28 void EmitWinEHHandlerData(SMLoc Loc) override;
30 void EmitCVFPOData(const MCSymbol *ProcSym, SMLoc Loc) override;
34 void X86WinCOFFStreamer::EmitWinEHHandlerData(SMLoc Loc) {
49 void X86WinCOFFStreamer::EmitCVFPOData(const MCSymbol *ProcSym, SMLoc Loc) {
lib/Target/X86/MCTargetDesc/X86WinCOFFTargetStreamer.cpp 34 SMLoc L) override;
35 bool emitFPOEndPrologue(SMLoc L) override;
36 bool emitFPOEndProc(SMLoc L) override;
37 bool emitFPOData(const MCSymbol *ProcSym, SMLoc L) override;
38 bool emitFPOPushReg(unsigned Reg, SMLoc L) override;
39 bool emitFPOStackAlloc(unsigned StackAlloc, SMLoc L) override;
40 bool emitFPOStackAlign(unsigned Align, SMLoc L) override;
41 bool emitFPOSetFrame(unsigned Reg, SMLoc L) override;
78 bool checkInFPOPrologue(SMLoc L);
88 SMLoc L) override;
89 bool emitFPOEndPrologue(SMLoc L) override;
90 bool emitFPOEndProc(SMLoc L) override;
91 bool emitFPOData(const MCSymbol *ProcSym, SMLoc L) override;
92 bool emitFPOPushReg(unsigned Reg, SMLoc L) override;
93 bool emitFPOStackAlloc(unsigned StackAlloc, SMLoc L) override;
94 bool emitFPOStackAlign(unsigned Align, SMLoc L) override;
95 bool emitFPOSetFrame(unsigned Reg, SMLoc L) override;
100 unsigned ParamsSize, SMLoc L) {
107 bool X86WinCOFFAsmTargetStreamer::emitFPOEndPrologue(SMLoc L) {
112 bool X86WinCOFFAsmTargetStreamer::emitFPOEndProc(SMLoc L) {
118 SMLoc L) {
125 bool X86WinCOFFAsmTargetStreamer::emitFPOPushReg(unsigned Reg, SMLoc L) {
133 SMLoc L) {
138 bool X86WinCOFFAsmTargetStreamer::emitFPOStackAlign(unsigned Align, SMLoc L) {
143 bool X86WinCOFFAsmTargetStreamer::emitFPOSetFrame(unsigned Reg, SMLoc L) {
150 bool X86WinCOFFTargetStreamer::checkInFPOPrologue(SMLoc L) {
167 unsigned ParamsSize, SMLoc L) {
180 bool X86WinCOFFTargetStreamer::emitFPOEndProc(SMLoc L) {
203 bool X86WinCOFFTargetStreamer::emitFPOSetFrame(unsigned Reg, SMLoc L) {
214 bool X86WinCOFFTargetStreamer::emitFPOPushReg(unsigned Reg, SMLoc L) {
225 bool X86WinCOFFTargetStreamer::emitFPOStackAlloc(unsigned StackAlloc, SMLoc L) {
236 bool X86WinCOFFTargetStreamer::emitFPOStackAlign(unsigned Align, SMLoc L) {
254 bool X86WinCOFFTargetStreamer::emitFPOEndPrologue(SMLoc L) {
385 bool X86WinCOFFTargetStreamer::emitFPOData(const MCSymbol *ProcSym, SMLoc L) {
tools/clang/lib/Parse/ParseStmtAsm.cpp 61 llvm::SMLoc Location,
80 llvm::SMLoc SMLoc);
129 llvm::SMLoc Location,
168 llvm::SMLoc SMLoc) {
tools/clang/utils/TableGen/NeonEmitter.cpp 1683 ArrayRef<SMLoc> Loc) override {
1693 ArrayRef<SMLoc> Loc) override {
1707 ArrayRef<SMLoc> Loc) override {
tools/llvm-exegesis/lib/SnippetFile.cpp 43 void HandleComment(SMLoc Loc, StringRef CommentText) override {
98 unsigned ByteAlignment, SMLoc Loc) override {}
tools/llvm-mc/Disassembler.cpp 53 SM.PrintMessage(SMLoc::getFromPointer(Bytes.second[Index]),
66 SM.PrintMessage(SMLoc::getFromPointer(Bytes.second[Index]),
117 SM.PrintMessage(SMLoc::getFromPointer(Value.data()), SourceMgr::DK_Error,
175 SM.PrintMessage(SMLoc::getFromPointer(Str.data()), SourceMgr::DK_Error,
184 SM.PrintMessage(SMLoc::getFromPointer(Str.data()), SourceMgr::DK_Error,
202 SM.PrintMessage(SMLoc::getFromPointer(Str.data()), SourceMgr::DK_Error,
tools/llvm-mca/CodeRegion.cpp 24 bool CodeRegion::isLocInRange(SMLoc Loc) const {
32 void CodeRegions::beginRegion(StringRef Description, SMLoc Loc) {
69 void CodeRegions::endRegion(StringRef Description, SMLoc Loc) {
110 SMLoc Loc = Instruction.getLoc();
tools/llvm-mca/CodeRegion.h 56 llvm::SMLoc RangeStart;
57 llvm::SMLoc RangeEnd;
63 CodeRegion(llvm::StringRef Desc, llvm::SMLoc Start)
70 llvm::SMLoc startLoc() const { return RangeStart; }
71 llvm::SMLoc endLoc() const { return RangeEnd; }
73 void setEndLocation(llvm::SMLoc End) { RangeEnd = End; }
75 bool isLocInRange(llvm::SMLoc Loc) const;
107 void beginRegion(llvm::StringRef Description, llvm::SMLoc Loc);
108 void endRegion(llvm::StringRef Description, llvm::SMLoc Loc);
tools/llvm-mca/CodeRegionGenerator.cpp 38 void HandleComment(SMLoc Loc, StringRef CommentText) override;
63 SMLoc Loc = SMLoc()) override {}
75 void MCACommentConsumer::HandleComment(SMLoc Loc, StringRef CommentText) {
unittests/Support/SourceMgrTest.cpp 30 SMLoc getLoc(unsigned Offset) {
31 return SMLoc::getFromPointer(
39 void printMessage(SMLoc Loc, SourceMgr::DiagKind Kind,
unittests/TableGen/CodeExpanderTest.cpp 112 CodeExpander(" $foo", Expansions, SMLoc::getFromPointer(In.data()), false)
116 SrcMgr, SMLoc::getFromPointer(In.data() + 1), "TestBuffer", 1, 1,
179 CodeExpander(In, Expansions, SMLoc::getFromPointer(In.data()), false)
183 SrcMgr, SMLoc::getFromPointer(In.data() + 8), "TestBuffer", 1, 8,
197 CodeExpander(In, Expansions, SMLoc::getFromPointer(In.data()), false)
200 DiagChecker.expect(SMDiagnostic(SrcMgr, SMLoc::getFromPointer(In.data() + 1),
usr/include/c++/7.4.0/bits/alloc_traits.h 387 using allocator_type = allocator<_Tp>;
389 using value_type = _Tp;
392 using pointer = _Tp*;
395 using const_pointer = const _Tp*;
474 construct(allocator_type& __a, _Up* __p, _Args&&... __args)
475 { __a.construct(__p, std::forward<_Args>(__args)...); }
usr/include/c++/7.4.0/bits/allocator.h 108 class allocator: public __allocator_base<_Tp>
113 typedef _Tp* pointer;
114 typedef const _Tp* const_pointer;
115 typedef _Tp& reference;
116 typedef const _Tp& const_reference;
117 typedef _Tp value_type;
137 allocator(const allocator<_Tp1>&) throw() { }
usr/include/c++/7.4.0/bits/move.h 72 constexpr _Tp&&
73 forward(typename std::remove_reference<_Tp>::type& __t) noexcept
83 constexpr _Tp&&
84 forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
98 move(_Tp&& __t) noexcept
usr/include/c++/7.4.0/bits/stl_iterator_base_types.h 181 typedef _Tp value_type;
183 typedef _Tp* pointer;
184 typedef _Tp& reference;
192 typedef _Tp value_type;
194 typedef const _Tp* pointer;
195 typedef const _Tp& reference;
usr/include/c++/7.4.0/bits/stl_map.h 103 typedef _Tp mapped_type;
104 typedef std::pair<const _Key, _Tp> value_type;
usr/include/c++/7.4.0/bits/stl_pair.h 100 return __and_<is_constructible<_T1, const _U1&>,
100 return __and_<is_constructible<_T1, const _U1&>,
101 is_constructible<_T2, const _U2&>>::value;
101 is_constructible<_T2, const _U2&>>::value;
107 return __and_<is_convertible<const _U1&, _T1>,
107 return __and_<is_convertible<const _U1&, _T1>,
108 is_convertible<const _U2&, _T2>>::value;
108 is_convertible<const _U2&, _T2>>::value;
114 return __and_<is_constructible<_T1, _U1&&>,
114 return __and_<is_constructible<_T1, _U1&&>,
115 is_constructible<_T2, _U2&&>>::value;
115 is_constructible<_T2, _U2&&>>::value;
121 return __and_<is_convertible<_U1&&, _T1>,
121 return __and_<is_convertible<_U1&&, _T1>,
122 is_convertible<_U2&&, _T2>>::value;
122 is_convertible<_U2&&, _T2>>::value;
128 using __do_converts = __and_<is_convertible<const _U1&, _T1>,
128 using __do_converts = __and_<is_convertible<const _U1&, _T1>,
129 is_convertible<_U2&&, _T2>>;
129 is_convertible<_U2&&, _T2>>;
133 return __and_<is_constructible<_T1, const _U1&>,
133 return __and_<is_constructible<_T1, const _U1&>,
134 is_constructible<_T2, _U2&&>,
134 is_constructible<_T2, _U2&&>,
142 using __do_converts = __and_<is_convertible<_U1&&, _T1>,
142 using __do_converts = __and_<is_convertible<_U1&&, _T1>,
143 is_convertible<const _U2&, _T2>>;
143 is_convertible<const _U2&, _T2>>;
147 return __and_<is_constructible<_T1, _U1&&>,
147 return __and_<is_constructible<_T1, _U1&&>,
148 is_constructible<_T2, const _U2&&>,
148 is_constructible<_T2, const _U2&&>,
209 : private __pair_base<_T1, _T2>
209 : private __pair_base<_T1, _T2>
211 typedef _T1 first_type; /// @c first_type is the first bound type
212 typedef _T2 second_type; /// @c second_type is the second bound type
214 _T1 first; /// @c first is a copy of the first object
215 _T2 second; /// @c second is a copy of the second object
252 using _PCCP = _PCC<true, _T1, _T2>;
252 using _PCCP = _PCC<true, _T1, _T2>;
260 constexpr pair(const _T1& __a, const _T2& __b)
260 constexpr pair(const _T1& __a, const _T2& __b)
269 explicit constexpr pair(const _T1& __a, const _T2& __b)
269 explicit constexpr pair(const _T1& __a, const _T2& __b)
283 _T1, _T2>;
283 _T1, _T2>;
291 constexpr pair(const pair<_U1, _U2>& __p)
291 constexpr pair(const pair<_U1, _U2>& __p)
311 constexpr pair(_U1&& __x, const _T2& __y)
311 constexpr pair(_U1&& __x, const _T2& __y)
312 : first(std::forward<_U1>(__x)), second(__y) { }
318 explicit constexpr pair(_U1&& __x, const _T2& __y)
325 constexpr pair(const _T1& __x, _U2&& __y)
325 constexpr pair(const _T1& __x, _U2&& __y)
326 : first(__x), second(std::forward<_U2>(__y)) { }
332 explicit pair(const _T1& __x, _U2&& __y)
341 constexpr pair(_U1&& __x, _U2&& __y)
341 constexpr pair(_U1&& __x, _U2&& __y)
342 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
342 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
360 constexpr pair(pair<_U1, _U2>&& __p)
360 constexpr pair(pair<_U1, _U2>&& __p)
361 : first(std::forward<_U1>(__p.first)),
362 second(std::forward<_U2>(__p.second)) { }
379 __and_<is_copy_assignable<_T1>,
380 is_copy_assignable<_T2>>::value,
390 __and_<is_move_assignable<_T1>,
391 is_move_assignable<_T2>>::value,
402 typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
402 typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
403 is_assignable<_T2&, const _U2&>>::value,
403 is_assignable<_T2&, const _U2&>>::value,
405 operator=(const pair<_U1, _U2>& __p)
405 operator=(const pair<_U1, _U2>& __p)
413 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
413 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
414 is_assignable<_T2&, _U2&&>>::value,
414 is_assignable<_T2&, _U2&&>>::value,
416 operator=(pair<_U1, _U2>&& __p)
416 operator=(pair<_U1, _U2>&& __p)
522 constexpr pair<typename __decay_and_strip<_T1>::__type,
523 typename __decay_and_strip<_T2>::__type>
524 make_pair(_T1&& __x, _T2&& __y)
524 make_pair(_T1&& __x, _T2&& __y)
526 typedef typename __decay_and_strip<_T1>::__type __ds_type1;
527 typedef typename __decay_and_strip<_T2>::__type __ds_type2;
529 return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
529 return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
usr/include/c++/7.4.0/bits/stl_vector.h 77 rebind<_Tp>::other _Tp_alloc_type;
216 class vector : protected _Vector_base<_Tp, _Alloc>
227 typedef _Vector_base<_Tp, _Alloc> _Base;
232 typedef _Tp value_type;
919 _Tp*
923 const _Tp*
962 emplace_back(_Args&&... __args);
1483 _M_realloc_insert(iterator __position, _Args&&... __args);
usr/include/c++/7.4.0/bits/unique_ptr.h 824 make_unique(_Args&&... __args)
825 { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
usr/include/c++/7.4.0/bits/vector.tcc 101 std::forward<_Args>(__args)...);
105 _M_realloc_insert(end(), std::forward<_Args>(__args)...);
418 std::forward<_Args>(__args)...);
usr/include/c++/7.4.0/ext/alloc_traits.h 117 { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
usr/include/c++/7.4.0/ext/new_allocator.h 63 typedef _Tp* pointer;
64 typedef const _Tp* const_pointer;
65 typedef _Tp& reference;
66 typedef const _Tp& const_reference;
67 typedef _Tp value_type;
135 construct(_Up* __p, _Args&&... __args)
136 { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
usr/include/c++/7.4.0/initializer_list 50 typedef _E value_type;
51 typedef const _E& reference;
52 typedef const _E& const_reference;
54 typedef const _E* iterator;
55 typedef const _E* const_iterator;
usr/include/c++/7.4.0/tuple 56 struct __is_empty_non_tuple : is_empty<_Tp> { };
125 constexpr _Head_base(const _Head& __h)
132 constexpr _Head_base(_UHead&& __h)
133 : _M_head_impl(std::forward<_UHead>(__h)) { }
159 static constexpr _Head&
162 static constexpr const _Head&
165 _Head _M_head_impl;
187 private _Head_base<_Idx, _Head>
192 typedef _Head_base<_Idx, _Head> _Base;
194 static constexpr _Head&
197 static constexpr const _Head&
210 constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
216 constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
227 _Base(std::forward<_Head>(_M_head(__in))) { }
230 constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
235 constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
248 const _Head& __head, const _Tail&... __tail)
473 return __and_<is_constructible<_Elements, const _UElements&>...>::value;
473 return __and_<is_constructible<_Elements, const _UElements&>...>::value;
479 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
479 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
485 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
485 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
491 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
491 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
508 return __not_<is_same<tuple<_Elements...>,
556 class tuple : public _Tuple_impl<0, _Elements...>
558 typedef _Tuple_impl<0, _Elements...> _Inherited;
567 return __and_<is_default_constructible<_Elements>...>::value;
571 return __and_<__is_implicitly_default_constructible<_Elements>...>
598 _Elements...>;
608 constexpr tuple(const _Elements&... __elements)
619 explicit constexpr tuple(const _Elements&... __elements)
628 _Elements...>;
636 _Elements...>;
646 constexpr tuple(_UElements&&... __elements)
668 _Elements...>;
730 const _Elements&... __elements)
741 const _Elements&... __elements)
853 operator=(const tuple<_UElements...>& __in)
863 operator=(tuple<_UElements...>&& __in)
1288 typedef _Head type;
1302 constexpr _Head&
1303 __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1304 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1307 constexpr const _Head&
1308 __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1313 constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1313 constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1313 constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1314 get(tuple<_Elements...>& __t) noexcept
1319 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1319 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1319 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1320 get(const tuple<_Elements...>& __t) noexcept
1325 constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
1325 constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
1325 constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
1326 get(tuple<_Elements...>&& __t) noexcept
1448 make_tuple(_Elements&&... __args)
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
326 : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
354 : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
381 : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
567 : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
588 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
588 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602 is_void<_Tp>>>::type
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
612 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
612 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
631 : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
762 typename add_rvalue_reference<_Tp>::type declval() noexcept;
777 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
777 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
798 typedef decltype(__test<_Tp>(0)) type;
811 remove_all_extents<_Tp>::type>::type
825 : public __is_destructible_safe<_Tp>::type
889 typedef decltype(__test<_Tp>(0)) type;
894 : public __and_<__not_<is_void<_Tp>>,
895 __is_default_constructible_impl<_Tp>>
915 : public __is_default_constructible_atom<_Tp>::type
921 : public __is_default_constructible_safe<_Tp>::type
984 typedef decltype(__test<_Tp, _Arg>(0)) type;
989 : public __and_<is_destructible<_Tp>,
990 __is_direct_constructible_impl<_Tp, _Arg>>
1072 __is_direct_constructible_ref_cast<_Tp, _Arg>,
1073 __is_direct_constructible_new_safe<_Tp, _Arg>
1079 : public __is_direct_constructible_new<_Tp, _Arg>::type
1119 : public __is_direct_constructible<_Tp, _Arg>
1130 : public __is_constructible_impl<_Tp, _Args...>::type
1142 : public is_constructible<_Tp, const _Tp&>
1142 : public is_constructible<_Tp, const _Tp&>
1148 : public __is_copy_constructible_impl<_Tp>
1160 : public is_constructible<_Tp, _Tp&&>
1160 : public is_constructible<_Tp, _Tp&&>
1166 : public __is_move_constructible_impl<_Tp>
1215 : public __and_<is_constructible<_Tp, _Args...>,
1216 __is_nt_constructible_impl<_Tp, _Args...>>
1246 : public is_nothrow_constructible<_Tp, _Tp&&>
1246 : public is_nothrow_constructible<_Tp, _Tp&&>
1252 : public __is_nothrow_move_constructible_impl<_Tp>
1286 : public is_assignable<_Tp&, const _Tp&>
1286 : public is_assignable<_Tp&, const _Tp&>
1292 : public __is_copy_assignable_impl<_Tp>
1304 : public is_assignable<_Tp&, _Tp&&>
1304 : public is_assignable<_Tp&, _Tp&&>
1310 : public __is_move_assignable_impl<_Tp>
1352 : public is_nothrow_assignable<_Tp&, _Tp&&>
1352 : public is_nothrow_assignable<_Tp&, _Tp&&>
1358 : public __is_nt_move_assignable_impl<_Tp>
1377 static void __helper(const _Tp&);
1380 static true_type __test(const _Tp&,
1381 decltype(__helper<const _Tp&>({}))* = 0);
1390 typedef decltype(__test(declval<_Tp>())) type;
1395 : public __is_implicitly_default_constructible_impl<_Tp>::type
1400 : public __and_<is_default_constructible<_Tp>,
1401 __is_implicitly_default_constructible_safe<_Tp>>
1526 static void __test_aux(_To1);
1538 typedef decltype(__test<_From, _To>(0)) type;
1545 : public __is_convertible_helper<_From, _To>::type
1554 { typedef _Tp type; };
1558 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1629 { typedef _Tp type; };
1633 { typedef _Tp type; };
1659 { typedef _Tp&& type; };
1664 : public __add_rvalue_reference_helper<_Tp>
1955 { typedef _Tp type; };
2104 { typedef typename remove_cv<_Up>::type __type; };
2118 typedef typename remove_reference<_Tp>::type __remove_type;
2131 typedef _Tp __type;
2144 typename decay<_Tp>::type>::__type __type;
utils/TableGen/AsmMatcherEmitter.cpp 815 parseTwoOperandConstraint(StringRef S, ArrayRef<SMLoc> Loc) {
utils/TableGen/CTagsEmitter.cpp 31 SMLoc Loc;
33 Tag(const std::string &Name, const SMLoc Location)
54 static SMLoc locate(const Record *R);
59 SMLoc CTagsEmitter::locate(const Record *R) {
60 ArrayRef<SMLoc> Locs = R->getLoc();
utils/TableGen/CodeGenInstruction.cpp 529 ArrayRef<SMLoc> Loc, CodeGenTarget &T,
utils/TableGen/CodeGenInstruction.h 375 Record *InstOpRec, bool hasSubOps, ArrayRef<SMLoc> Loc,
utils/TableGen/CodeGenRegisters.cpp 360 ArrayRef<SMLoc> Loc;
377 ArrayRef<SMLoc> Loc;
utils/TableGen/CodeGenSchedule.cpp 47 ArrayRef<SMLoc> Loc) override {
79 ArrayRef<SMLoc> Loc) override {
2057 ArrayRef<SMLoc> Loc) const {
2098 ArrayRef<SMLoc> Loc) {
utils/TableGen/CodeGenSchedule.h 570 ArrayRef<SMLoc> Loc) const;
637 ArrayRef<SMLoc> Loc);
utils/TableGen/CodeGenTarget.cpp 605 ArrayRef<SMLoc> DefLoc = R->getLoc();
utils/TableGen/DAGISelMatcherEmitter.cpp 206 SMLoc L;
utils/TableGen/GlobalISel/CodeExpander.cpp 64 ? SMLoc::getFromPointer(Loc[0].getPointer() + LocOffset)
73 ? SMLoc::getFromPointer(Loc[0].getPointer() + LocOffset)
87 ? SMLoc::getFromPointer(Loc[0].getPointer() + LocOffset)
utils/TableGen/GlobalISel/CodeExpander.h 35 const ArrayRef<SMLoc> &Loc;
41 const ArrayRef<SMLoc> &Loc, bool ShowExpansions,
utils/TableGen/GlobalISelEmitter.cpp 848 ArrayRef<SMLoc> SrcLoc;
861 RuleMatcher(ArrayRef<SMLoc> SrcLoc)
utils/unittest/googletest/include/gtest/gtest-printers.h 140 static void PrintValue(const T& value, ::std::ostream* os) {
205 ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
206 TypeWithoutFormatter<T,
207 (internal::IsAProtocolMessage<T>::value ? kProtobuf :
208 internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
223 void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
276 static ::std::string Format(const ToPrint& value) {
351 const T1& value, const T2& /* other_operand */) {
351 const T1& value, const T2& /* other_operand */) {
352 return FormatForComparison<T1, T2>::Format(value);
352 return FormatForComparison<T1, T2>::Format(value);
366 void UniversalPrint(const T& value, ::std::ostream* os);
373 const C& container, ::std::ostream* os) {
439 const T& value, ::std::ostream* os) {
455 void PrintTo(const T& value, ::std::ostream* os) {
478 DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
699 static void Print(const T& value, ::std::ostream* os) {
784 static void Print(const T& value, ::std::ostream* os) {
856 typedef T T1;
983 internal::UniversalTersePrinter<T>::Print(value, &ss);
utils/unittest/googletest/include/gtest/gtest.h 1377 const T1& lhs, const T2& rhs) {
1377 const T1& lhs, const T2& rhs) {
1389 const T1& lhs,
1390 const T2& rhs) {
1419 const T1& lhs,
1420 const T2& rhs) {
utils/unittest/googletest/include/gtest/internal/custom/raw-ostream.h 29 static const T& printable(const T& V) { return V; }
29 static const T& printable(const T& V) { return V; }
35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
37 return StreamSwitch<T>::printable(V);
utils/unittest/googletest/include/gtest/internal/gtest-internal.h 94 ::std::string PrintToString(const T& value);