include/llvm/MC/MCSymbolMachO.h

   1 //===- MCSymbolMachO.h -  ---------------------------------------*- 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 #ifndef LLVM_MC_MCSYMBOLMACHO_H
   9 #define LLVM_MC_MCSYMBOLMACHO_H
  10
  11 #include "llvm/ADT/Twine.h"
  12 #include "llvm/MC/MCSymbol.h"
  13
  14 namespace llvm {
  15 class MCSymbolMachO : public MCSymbol {
  16   /// We store the value for the 'desc' symbol field in the
  17   /// lowest 16 bits of the implementation defined flags.
  18   enum MachOSymbolFlags : uint16_t { // See <mach-o/nlist.h>.
  19     SF_DescFlagsMask                        = 0xFFFF,
  20
  21     // Reference type flags.
  22     SF_ReferenceTypeMask                    = 0x0007,
  23     SF_ReferenceTypeUndefinedNonLazy        = 0x0000,
  24     SF_ReferenceTypeUndefinedLazy           = 0x0001,
  25     SF_ReferenceTypeDefined                 = 0x0002,
  26     SF_ReferenceTypePrivateDefined          = 0x0003,
  27     SF_ReferenceTypePrivateUndefinedNonLazy = 0x0004,
  28     SF_ReferenceTypePrivateUndefinedLazy    = 0x0005,
  29
  30     // Other 'desc' flags.
  31     SF_ThumbFunc                            = 0x0008,
  32     SF_NoDeadStrip                          = 0x0020,
  33     SF_WeakReference                        = 0x0040,
  34     SF_WeakDefinition                       = 0x0080,
  35     SF_SymbolResolver                       = 0x0100,
  36     SF_AltEntry                             = 0x0200,
  37     SF_Cold                                 = 0x0400,
  38
  39     // Common alignment
  40     SF_CommonAlignmentMask                  = 0xF0FF,
  41     SF_CommonAlignmentShift                 = 8
  42   };
  43
  44 public:
  45   MCSymbolMachO(const StringMapEntry<bool> *Name, bool isTemporary)
  46       : MCSymbol(SymbolKindMachO, Name, isTemporary) {}
  47
  48   // Reference type methods.
  49
  50   void clearReferenceType() const {
  51     modifyFlags(0, SF_ReferenceTypeMask);
  52   }
  53
  54   void setReferenceTypeUndefinedLazy(bool Value) const {
  55     modifyFlags(Value ? SF_ReferenceTypeUndefinedLazy : 0,
  56                 SF_ReferenceTypeUndefinedLazy);
  57   }
  58
  59   // Other 'desc' methods.
  60
  61   void setThumbFunc() const {
  62     modifyFlags(SF_ThumbFunc, SF_ThumbFunc);
  63   }
  64
  65   bool isNoDeadStrip() const {
  66     return getFlags() & SF_NoDeadStrip;
  67   }
  68   void setNoDeadStrip() const {
  69     modifyFlags(SF_NoDeadStrip, SF_NoDeadStrip);
  70   }
  71
  72   bool isWeakReference() const {
  73     return getFlags() & SF_WeakReference;
  74   }
  75   void setWeakReference() const {
  76     modifyFlags(SF_WeakReference, SF_WeakReference);
  77   }
  78
  79   bool isWeakDefinition() const {
  80     return getFlags() & SF_WeakDefinition;
  81   }
  82   void setWeakDefinition() const {
  83     modifyFlags(SF_WeakDefinition, SF_WeakDefinition);
  84   }
  85
  86   bool isSymbolResolver() const {
  87     return getFlags() & SF_SymbolResolver;
  88   }
  89   void setSymbolResolver() const {
  90     modifyFlags(SF_SymbolResolver, SF_SymbolResolver);
  91   }
  92
  93   void setAltEntry() const {
  94     modifyFlags(SF_AltEntry, SF_AltEntry);
  95   }
  96
  97   bool isAltEntry() const {
  98     return getFlags() & SF_AltEntry;
  99   }
 100
 101   void setCold() const { modifyFlags(SF_Cold, SF_Cold); }
 102
 103   bool isCold() const { return getFlags() & SF_Cold; }
 104
 105   void setDesc(unsigned Value) const {
 106     assert(Value == (Value & SF_DescFlagsMask) &&
 107            "Invalid .desc value!");
 108     setFlags(Value & SF_DescFlagsMask);
 109   }
 110
 111   /// Get the encoded value of the flags as they will be emitted in to
 112   /// the MachO binary
 113   uint16_t getEncodedFlags(bool EncodeAsAltEntry) const {
 114     uint16_t Flags = getFlags();
 115
 116     // Common alignment is packed into the 'desc' bits.
 117     if (isCommon()) {
 118       if (unsigned Align = getCommonAlignment()) {
 119         unsigned Log2Size = Log2_32(Align);
 120         assert((1U << Log2Size) == Align && "Invalid 'common' alignment!");
 121         if (Log2Size > 15)
 122           report_fatal_error("invalid 'common' alignment '" +
 123                              Twine(Align) + "' for '" + getName() + "'",
 124                              false);
 125         Flags = (Flags & SF_CommonAlignmentMask) |
 126                 (Log2Size << SF_CommonAlignmentShift);
 127       }
 128     }
 129
 130     if (EncodeAsAltEntry)
 131       Flags |= SF_AltEntry;
 132
 133     return Flags;
 134   }
 135
 136   static bool classof(const MCSymbol *S) { return S->isMachO(); }
 137 };
 138 }
 139
 140 #endif