Bug Summary

File:llvm/lib/Target/BPF/MCTargetDesc/BPFELFObjectWriter.cpp
Warning:line 62, column 26
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name BPFELFObjectWriter.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/Target/BPF/MCTargetDesc -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/Target/BPF/MCTargetDesc -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/Target/BPF/MCTargetDesc -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/Target/BPF -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/Target/BPF -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include -D NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/Target/BPF/MCTargetDesc -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e=. -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-09-04-040900-46481-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/Target/BPF/MCTargetDesc/BPFELFObjectWriter.cpp

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/Target/BPF/MCTargetDesc/BPFELFObjectWriter.cpp

→
1//===-- BPFELFObjectWriter.cpp - BPF ELF Writer ---------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "MCTargetDesc/BPFMCTargetDesc.h"
10#include "llvm/BinaryFormat/ELF.h"
11#include "llvm/MC/MCELFObjectWriter.h"
12#include "llvm/MC/MCFixup.h"
13#include "llvm/MC/MCObjectWriter.h"
14#include "llvm/MC/MCValue.h"
15#include "llvm/Support/ErrorHandling.h"
16#include <cstdint>
17
18using namespace llvm;
19
20namespace {
21
22class BPFELFObjectWriter : public MCELFObjectTargetWriter {
23public:
24 BPFELFObjectWriter(uint8_t OSABI);
25 ~BPFELFObjectWriter() override = default;
26
27protected:
28 unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
29 const MCFixup &Fixup, bool IsPCRel) const override;
30};
31
32} // end anonymous namespace
33
34BPFELFObjectWriter::BPFELFObjectWriter(uint8_t OSABI)
35 : MCELFObjectTargetWriter(/*Is64Bit*/ true, OSABI, ELF::EM_BPF,
36 /*HasRelocationAddend*/ false) {}
37
38unsigned BPFELFObjectWriter::getRelocType(MCContext &Ctx, const MCValue &Target,
39 const MCFixup &Fixup,
40 bool IsPCRel) const {
41 // determine the type of the relocation
42 switch (Fixup.getKind()) {
1
Control jumps to 'case FK_Data_4:' at line 53
→
43 default:
44 llvm_unreachable("invalid fixup kind!")__builtin_unreachable();
45 case FK_SecRel_8:
46 // LD_imm64 instruction.
47 return ELF::R_BPF_64_64;
48 case FK_PCRel_4:
49 // CALL instruction.
50 return ELF::R_BPF_64_32;
51 case FK_Data_8:
52 return ELF::R_BPF_64_ABS64;
53 case FK_Data_4:
54 if (const MCSymbolRefExpr *A = Target.getSymA()) {
2
←
Assuming 'A' is non-null
→
3
←
Taking true branch
→
55 const MCSymbol &Sym = A->getSymbol();
56
57 if (Sym.isDefined()) {
4
←
Calling 'MCSymbol::isDefined'
→
9
←
Returning from 'MCSymbol::isDefined'
→
10
←
Taking true branch
→
58 MCSection &Section = Sym.getSection();
59 const MCSectionELF *SectionELF = dyn_cast<MCSectionELF>(&Section);
11
←
Assuming the object is not a 'MCSectionELF'
→
12
←
'SectionELF' initialized to a null pointer value
→
60 assert(SectionELF && "Null section for reloc symbol")(static_cast<void> (0));
61
62 unsigned Flags = SectionELF->getFlags();
13
←
Called C++ object pointer is null
63
64 if (Sym.isTemporary()) {
65 // .BTF.ext generates FK_Data_4 relocations for
66 // insn offset by creating temporary labels.
67 // The reloc symbol should be in text section.
68 // Use a different relocation to instruct ExecutionEngine
69 // RuntimeDyld not to do relocation for it, yet still to
70 // allow lld to do proper adjustment when merging sections.
71 if ((Flags & ELF::SHF_ALLOC) && (Flags & ELF::SHF_EXECINSTR))
72 return ELF::R_BPF_64_NODYLD32;
73 } else {
74 // .BTF generates FK_Data_4 relocations for variable
75 // offset in DataSec kind.
76 // The reloc symbol should be in data section.
77 if ((Flags & ELF::SHF_ALLOC) && (Flags & ELF::SHF_WRITE))
78 return ELF::R_BPF_64_NODYLD32;
79 }
80 }
81 }
82 return ELF::R_BPF_64_ABS32;
83 }
84}
85
86std::unique_ptr<MCObjectTargetWriter>
87llvm::createBPFELFObjectWriter(uint8_t OSABI) {
88 return std::make_unique<BPFELFObjectWriter>(OSABI);
89}
←

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include/llvm/MC/MCSymbol.h

1//===- MCSymbol.h - Machine Code Symbols ------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains the declaration of the MCSymbol class.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_MC_MCSYMBOL_H
14#define LLVM_MC_MCSYMBOL_H
15
16#include "llvm/ADT/PointerIntPair.h"
17#include "llvm/ADT/StringMap.h"
18#include "llvm/ADT/StringRef.h"
19#include "llvm/MC/MCExpr.h"
20#include "llvm/MC/MCFragment.h"
21#include "llvm/Support/ErrorHandling.h"
22#include "llvm/Support/MathExtras.h"
23#include <cassert>
24#include <cstddef>
25#include <cstdint>
26
27namespace llvm {
28
29class MCAsmInfo;
30class MCContext;
31class MCSection;
32class raw_ostream;
33
34/// MCSymbol - Instances of this class represent a symbol name in the MC file,
35/// and MCSymbols are created and uniqued by the MCContext class. MCSymbols
36/// should only be constructed with valid names for the object file.
37///
38/// If the symbol is defined/emitted into the current translation unit, the
39/// Section member is set to indicate what section it lives in. Otherwise, if
40/// it is a reference to an external entity, it has a null section.
41class MCSymbol {
42protected:
43 /// The kind of the symbol. If it is any value other than unset then this
44 /// class is actually one of the appropriate subclasses of MCSymbol.
45 enum SymbolKind {
46 SymbolKindUnset,
47 SymbolKindCOFF,
48 SymbolKindELF,
49 SymbolKindGOFF,
50 SymbolKindMachO,
51 SymbolKindWasm,
52 SymbolKindXCOFF,
53 };
54
55 /// A symbol can contain an Offset, or Value, or be Common, but never more
56 /// than one of these.
57 enum Contents : uint8_t {
58 SymContentsUnset,
59 SymContentsOffset,
60 SymContentsVariable,
61 SymContentsCommon,
62 SymContentsTargetCommon, // Index stores the section index
63 };
64
65 // Special sentinal value for the absolute pseudo fragment.
66 static MCFragment *AbsolutePseudoFragment;
67
68 /// If a symbol has a Fragment, the section is implied, so we only need
69 /// one pointer.
70 /// The special AbsolutePseudoFragment value is for absolute symbols.
71 /// If this is a variable symbol, this caches the variable value's fragment.
72 /// FIXME: We might be able to simplify this by having the asm streamer create
73 /// dummy fragments.
74 /// If this is a section, then it gives the symbol is defined in. This is null
75 /// for undefined symbols.
76 ///
77 /// If this is a fragment, then it gives the fragment this symbol's value is
78 /// relative to, if any.
79 ///
80 /// For the 'HasName' integer, this is true if this symbol is named.
81 /// A named symbol will have a pointer to the name allocated in the bytes
82 /// immediately prior to the MCSymbol.
83 mutable PointerIntPair<MCFragment *, 1> FragmentAndHasName;
84
85 /// IsTemporary - True if this is an assembler temporary label, which
86 /// typically does not survive in the .o file's symbol table. Usually
87 /// "Lfoo" or ".foo".
88 unsigned IsTemporary : 1;
89
90 /// True if this symbol can be redefined.
91 unsigned IsRedefinable : 1;
92
93 /// IsUsed - True if this symbol has been used.
94 mutable unsigned IsUsed : 1;
95
96 mutable unsigned IsRegistered : 1;
97
98 /// True if this symbol is visible outside this translation unit. Note: ELF
99 /// uses binding instead of this bit.
100 mutable unsigned IsExternal : 1;
101
102 /// This symbol is private extern.
103 mutable unsigned IsPrivateExtern : 1;
104
105 /// LLVM RTTI discriminator. This is actually a SymbolKind enumerator, but is
106 /// unsigned to avoid sign extension and achieve better bitpacking with MSVC.
107 unsigned Kind : 3;
108
109 /// True if we have created a relocation that uses this symbol.
110 mutable unsigned IsUsedInReloc : 1;
111
112 /// This is actually a Contents enumerator, but is unsigned to avoid sign
113 /// extension and achieve better bitpacking with MSVC.
114 unsigned SymbolContents : 3;
115
116 /// The alignment of the symbol, if it is 'common', or -1.
117 ///
118 /// The alignment is stored as log2(align) + 1. This allows all values from
119 /// 0 to 2^31 to be stored which is every power of 2 representable by an
120 /// unsigned.
121 enum : unsigned { NumCommonAlignmentBits = 5 };
122 unsigned CommonAlignLog2 : NumCommonAlignmentBits;
123
124 /// The Flags field is used by object file implementations to store
125 /// additional per symbol information which is not easily classified.
126 enum : unsigned { NumFlagsBits = 16 };
127 mutable uint32_t Flags : NumFlagsBits;
128
129 /// Index field, for use by the object file implementation.
130 mutable uint32_t Index = 0;
131
132 union {
133 /// The offset to apply to the fragment address to form this symbol's value.
134 uint64_t Offset;
135
136 /// The size of the symbol, if it is 'common'.
137 uint64_t CommonSize;
138
139 /// If non-null, the value for a variable symbol.
140 const MCExpr *Value;
141 };
142
143 // MCContext creates and uniques these.
144 friend class MCExpr;
145 friend class MCContext;
146
147 /// The name for a symbol.
148 /// MCSymbol contains a uint64_t so is probably aligned to 8. On a 32-bit
149 /// system, the name is a pointer so isn't going to satisfy the 8 byte
150 /// alignment of uint64_t. Account for that here.
151 using NameEntryStorageTy = union {
152 const StringMapEntry<bool> *NameEntry;
153 uint64_t AlignmentPadding;
154 };
155
156 MCSymbol(SymbolKind Kind, const StringMapEntry<bool> *Name, bool isTemporary)
157 : IsTemporary(isTemporary), IsRedefinable(false), IsUsed(false),
158 IsRegistered(false), IsExternal(false), IsPrivateExtern(false),
159 Kind(Kind), IsUsedInReloc(false), SymbolContents(SymContentsUnset),
160 CommonAlignLog2(0), Flags(0) {
161 Offset = 0;
162 FragmentAndHasName.setInt(!!Name);
163 if (Name)
164 getNameEntryPtr() = Name;
165 }
166
167 // Provide custom new/delete as we will only allocate space for a name
168 // if we need one.
169 void *operator new(size_t s, const StringMapEntry<bool> *Name,
170 MCContext &Ctx);
171
172private:
173 void operator delete(void *);
174 /// Placement delete - required by std, but never called.
175 void operator delete(void*, unsigned) {
176 llvm_unreachable("Constructor throws?")__builtin_unreachable();
177 }
178 /// Placement delete - required by std, but never called.
179 void operator delete(void*, unsigned, bool) {
180 llvm_unreachable("Constructor throws?")__builtin_unreachable();
181 }
182
183 /// Get a reference to the name field. Requires that we have a name
184 const StringMapEntry<bool> *&getNameEntryPtr() {
185 assert(FragmentAndHasName.getInt() && "Name is required")(static_cast<void> (0));
186 NameEntryStorageTy *Name = reinterpret_cast<NameEntryStorageTy *>(this);
187 return (*(Name - 1)).NameEntry;
188 }
189 const StringMapEntry<bool> *&getNameEntryPtr() const {
190 return const_cast<MCSymbol*>(this)->getNameEntryPtr();
191 }
192
193public:
194 MCSymbol(const MCSymbol &) = delete;
195 MCSymbol &operator=(const MCSymbol &) = delete;
196
197 /// getName - Get the symbol name.
198 StringRef getName() const {
199 if (!FragmentAndHasName.getInt())
200 return StringRef();
201
202 return getNameEntryPtr()->first();
203 }
204
205 bool isRegistered() const { return IsRegistered; }
206 void setIsRegistered(bool Value) const { IsRegistered = Value; }
207
208 void setUsedInReloc() const { IsUsedInReloc = true; }
209 bool isUsedInReloc() const { return IsUsedInReloc; }
210
211 /// \name Accessors
212 /// @{
213
214 /// isTemporary - Check if this is an assembler temporary symbol.
215 bool isTemporary() const { return IsTemporary; }
216
217 /// isUsed - Check if this is used.
218 bool isUsed() const { return IsUsed; }
219
220 /// Check if this symbol is redefinable.
221 bool isRedefinable() const { return IsRedefinable; }
222 /// Mark this symbol as redefinable.
223 void setRedefinable(bool Value) { IsRedefinable = Value; }
224 /// Prepare this symbol to be redefined.
225 void redefineIfPossible() {
226 if (IsRedefinable) {
227 if (SymbolContents == SymContentsVariable) {
228 Value = nullptr;
229 SymbolContents = SymContentsUnset;
230 }
231 setUndefined();
232 IsRedefinable = false;
233 }
234 }
235
236 /// @}
237 /// \name Associated Sections
238 /// @{
239
240 /// isDefined - Check if this symbol is defined (i.e., it has an address).
241 ///
242 /// Defined symbols are either absolute or in some section.
243 bool isDefined() const { return !isUndefined(); }
5
←
Calling 'MCSymbol::isUndefined'
→
7
←
Returning from 'MCSymbol::isUndefined'
→
8
←
Returning the value 1, which participates in a condition later
→
244
245 /// isInSection - Check if this symbol is defined in some section (i.e., it
246 /// is defined but not absolute).
247 bool isInSection() const {
248 return isDefined() && !isAbsolute();
249 }
250
251 /// isUndefined - Check if this symbol undefined (i.e., implicitly defined).
252 bool isUndefined(bool SetUsed = true) const {
253 return getFragment(SetUsed) == nullptr;
6
←
Returning zero, which participates in a condition later
→
254 }
255
256 /// isAbsolute - Check if this is an absolute symbol.
257 bool isAbsolute() const {
258 return getFragment() == AbsolutePseudoFragment;
259 }
260
261 /// Get the section associated with a defined, non-absolute symbol.
262 MCSection &getSection() const {
263 assert(isInSection() && "Invalid accessor!")(static_cast<void> (0));
264 return *getFragment()->getParent();
265 }
266
267 /// Mark the symbol as defined in the fragment \p F.
268 void setFragment(MCFragment *F) const {
269 assert(!isVariable() && "Cannot set fragment of variable")(static_cast<void> (0));
270 FragmentAndHasName.setPointer(F);
271 }
272
273 /// Mark the symbol as undefined.
274 void setUndefined() { FragmentAndHasName.setPointer(nullptr); }
275
276 bool isELF() const { return Kind == SymbolKindELF; }
277
278 bool isCOFF() const { return Kind == SymbolKindCOFF; }
279
280 bool isGOFF() const { return Kind == SymbolKindGOFF; }
281
282 bool isMachO() const { return Kind == SymbolKindMachO; }
283
284 bool isWasm() const { return Kind == SymbolKindWasm; }
285
286 bool isXCOFF() const { return Kind == SymbolKindXCOFF; }
287
288 /// @}
289 /// \name Variable Symbols
290 /// @{
291
292 /// isVariable - Check if this is a variable symbol.
293 bool isVariable() const {
294 return SymbolContents == SymContentsVariable;
295 }
296
297 /// getVariableValue - Get the value for variable symbols.
298 const MCExpr *getVariableValue(bool SetUsed = true) const {
299 assert(isVariable() && "Invalid accessor!")(static_cast<void> (0));
300 IsUsed |= SetUsed;
301 return Value;
302 }
303
304 void setVariableValue(const MCExpr *Value);
305
306 /// @}
307
308 /// Get the (implementation defined) index.
309 uint32_t getIndex() const {
310 return Index;
311 }
312
313 /// Set the (implementation defined) index.
314 void setIndex(uint32_t Value) const {
315 Index = Value;
316 }
317
318 bool isUnset() const { return SymbolContents == SymContentsUnset; }
319
320 uint64_t getOffset() const {
321 assert((SymbolContents == SymContentsUnset ||(static_cast<void> (0))
322 SymbolContents == SymContentsOffset) &&(static_cast<void> (0))
323 "Cannot get offset for a common/variable symbol")(static_cast<void> (0));
324 return Offset;
325 }
326 void setOffset(uint64_t Value) {
327 assert((SymbolContents == SymContentsUnset ||(static_cast<void> (0))
328 SymbolContents == SymContentsOffset) &&(static_cast<void> (0))
329 "Cannot set offset for a common/variable symbol")(static_cast<void> (0));
330 Offset = Value;
331 SymbolContents = SymContentsOffset;
332 }
333
334 /// Return the size of a 'common' symbol.
335 uint64_t getCommonSize() const {
336 assert(isCommon() && "Not a 'common' symbol!")(static_cast<void> (0));
337 return CommonSize;
338 }
339
340 /// Mark this symbol as being 'common'.
341 ///
342 /// \param Size - The size of the symbol.
343 /// \param Align - The alignment of the symbol.
344 /// \param Target - Is the symbol a target-specific common-like symbol.
345 void setCommon(uint64_t Size, unsigned Align, bool Target = false) {
346 assert(getOffset() == 0)(static_cast<void> (0));
347 CommonSize = Size;
348 SymbolContents = Target ? SymContentsTargetCommon : SymContentsCommon;
349
350 assert((!Align || isPowerOf2_32(Align)) &&(static_cast<void> (0))
351 "Alignment must be a power of 2")(static_cast<void> (0));
352 unsigned Log2Align = Log2_32(Align) + 1;
353 assert(Log2Align < (1U << NumCommonAlignmentBits) &&(static_cast<void> (0))
354 "Out of range alignment")(static_cast<void> (0));
355 CommonAlignLog2 = Log2Align;
356 }
357
358 /// Return the alignment of a 'common' symbol.
359 unsigned getCommonAlignment() const {
360 assert(isCommon() && "Not a 'common' symbol!")(static_cast<void> (0));
361 return CommonAlignLog2 ? (1U << (CommonAlignLog2 - 1)) : 0;
362 }
363
364 /// Declare this symbol as being 'common'.
365 ///
366 /// \param Size - The size of the symbol.
367 /// \param Align - The alignment of the symbol.
368 /// \param Target - Is the symbol a target-specific common-like symbol.
369 /// \return True if symbol was already declared as a different type
370 bool declareCommon(uint64_t Size, unsigned Align, bool Target = false) {
371 assert(isCommon() || getOffset() == 0)(static_cast<void> (0));
372 if(isCommon()) {
373 if (CommonSize != Size || getCommonAlignment() != Align ||
374 isTargetCommon() != Target)
375 return true;
376 } else
377 setCommon(Size, Align, Target);
378 return false;
379 }
380
381 /// Is this a 'common' symbol.
382 bool isCommon() const {
383 return SymbolContents == SymContentsCommon ||
384 SymbolContents == SymContentsTargetCommon;
385 }
386
387 /// Is this a target-specific common-like symbol.
388 bool isTargetCommon() const {
389 return SymbolContents == SymContentsTargetCommon;
390 }
391
392 MCFragment *getFragment(bool SetUsed = true) const {
393 MCFragment *Fragment = FragmentAndHasName.getPointer();
394 if (Fragment || !isVariable())
395 return Fragment;
396 Fragment = getVariableValue(SetUsed)->findAssociatedFragment();
397 FragmentAndHasName.setPointer(Fragment);
398 return Fragment;
399 }
400
401 bool isExternal() const { return IsExternal; }
402 void setExternal(bool Value) const { IsExternal = Value; }
403
404 bool isPrivateExtern() const { return IsPrivateExtern; }
405 void setPrivateExtern(bool Value) { IsPrivateExtern = Value; }
406
407 /// print - Print the value to the stream \p OS.
408 void print(raw_ostream &OS, const MCAsmInfo *MAI) const;
409
410 /// dump - Print the value to stderr.
411 void dump() const;
412
413protected:
414 /// Get the (implementation defined) symbol flags.
415 uint32_t getFlags() const { return Flags; }
416
417 /// Set the (implementation defined) symbol flags.
418 void setFlags(uint32_t Value) const {
419 assert(Value < (1U << NumFlagsBits) && "Out of range flags")(static_cast<void> (0));
420 Flags = Value;
421 }
422
423 /// Modify the flags via a mask
424 void modifyFlags(uint32_t Value, uint32_t Mask) const {
425 assert(Value < (1U << NumFlagsBits) && "Out of range flags")(static_cast<void> (0));
426 Flags = (Flags & ~Mask) | Value;
427 }
428};
429
430inline raw_ostream &operator<<(raw_ostream &OS, const MCSymbol &Sym) {
431 Sym.print(OS, nullptr);
432 return OS;
433}
434
435} // end namespace llvm
436
437#endif // LLVM_MC_MCSYMBOL_H