Merge branch 'main' into hliao/main/fix-cir-dependency

Author: darkbuck

llvm/include/llvm/IR/FMF.h

@@ -23,13 +23,7 @@ class FastMathFlags {
 
   unsigned Flags = 0;
 
-  FastMathFlags(unsigned F) {
-    // If all 7 bits are set, turn this into -1. If the number of bits grows,
-    // this must be updated. This is intended to provide some forward binary
-    // compatibility insurance for the meaning of 'fast' in case bits are added.
-    if (F == 0x7F) Flags = ~0U;
-    else Flags = F;
-  }
+  FastMathFlags(unsigned F) : Flags(F) {}
 
 public:
   // This is how the bits are used in Value::SubclassOptionalData so they
@@ -43,9 +37,12 @@ class FastMathFlags {
     NoSignedZeros   = (1 << 3),
     AllowReciprocal = (1 << 4),
     AllowContract   = (1 << 5),
-    ApproxFunc      = (1 << 6)
+    ApproxFunc      = (1 << 6),
+    FlagEnd         = (1 << 7)
   };
 
+  constexpr static unsigned AllFlagsMask = FlagEnd - 1;
+
   FastMathFlags() = default;
 
   static FastMathFlags getFast() {
@@ -56,10 +53,10 @@ class FastMathFlags {
 
   bool any() const { return Flags != 0; }
   bool none() const { return Flags == 0; }
-  bool all() const { return Flags == ~0U; }
+  bool all() const { return Flags == AllFlagsMask; }
 
   void clear() { Flags = 0; }
-  void set()   { Flags = ~0U; }
+  void set() { Flags = AllFlagsMask; }
 
   /// Flag queries
   bool allowReassoc() const    { return 0 != (Flags & AllowReassoc); }

llvm/include/llvm/Transforms/Instrumentation/AddressSanitizerCommon.h

@@ -58,6 +58,12 @@ void getAddressSanitizerParams(const Triple &TargetTriple, int LongSize,
                                bool IsKasan, uint64_t *ShadowBase,
                                int *MappingScale, bool *OrShadowOffset);
 
+/// Remove memory attributes that are incompatible with the instrumentation
+/// added by AddressSanitizer and HWAddressSanitizer.
+/// \p ReadsArgMem - indicates whether function arguments may be read by
+/// instrumentation and require removing `writeonly` attributes.
+void removeASanIncompatibleFnAttributes(Function &F, bool ReadsArgMem);
+
 } // namespace llvm
 
 #endif

llvm/lib/Target/Mips/MCTargetDesc/MipsELFObjectWriter.cpp

@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "MCTargetDesc/MipsFixupKinds.h"
+#include "MCTargetDesc/MipsMCExpr.h"
 #include "MCTargetDesc/MipsMCTargetDesc.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/BinaryFormat/ELF.h"
@@ -161,6 +162,22 @@ unsigned MipsELFObjectWriter::getRelocType(MCContext &Ctx,
   if (Kind >= FirstLiteralRelocationKind)
     return Kind - FirstLiteralRelocationKind;
 
+  switch (Target.getRefKind()) {
+  case MipsMCExpr::MEK_DTPREL:
+  case MipsMCExpr::MEK_DTPREL_HI:
+  case MipsMCExpr::MEK_DTPREL_LO:
+  case MipsMCExpr::MEK_TLSLDM:
+  case MipsMCExpr::MEK_TLSGD:
+  case MipsMCExpr::MEK_GOTTPREL:
+  case MipsMCExpr::MEK_TPREL_HI:
+  case MipsMCExpr::MEK_TPREL_LO:
+    if (auto *S = Target.getSymA())
+      cast<MCSymbolELF>(S->getSymbol()).setType(ELF::STT_TLS);
+    break;
+  default:
+    break;
+  }
+
   switch (Kind) {
   case FK_NONE:
     return ELF::R_MIPS_NONE;

llvm/lib/Target/Mips/MCTargetDesc/MipsMCExpr.cpp

@@ -219,73 +219,6 @@ void MipsMCExpr::visitUsedExpr(MCStreamer &Streamer) const {
   Streamer.visitUsedExpr(*getSubExpr());
 }
 
-static void fixELFSymbolsInTLSFixupsImpl(const MCExpr *Expr, MCAssembler &Asm) {
-  switch (Expr->getKind()) {
-  case MCExpr::Target:
-    fixELFSymbolsInTLSFixupsImpl(cast<MipsMCExpr>(Expr)->getSubExpr(), Asm);
-    break;
-  case MCExpr::Constant:
-    break;
-  case MCExpr::Binary: {
-    const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
-    fixELFSymbolsInTLSFixupsImpl(BE->getLHS(), Asm);
-    fixELFSymbolsInTLSFixupsImpl(BE->getRHS(), Asm);
-    break;
-  }
-  case MCExpr::SymbolRef: {
-    // We're known to be under a TLS fixup, so any symbol should be
-    // modified. There should be only one.
-    const MCSymbolRefExpr &SymRef = *cast<MCSymbolRefExpr>(Expr);
-    cast<MCSymbolELF>(SymRef.getSymbol()).setType(ELF::STT_TLS);
-    break;
-  }
-  case MCExpr::Unary:
-    fixELFSymbolsInTLSFixupsImpl(cast<MCUnaryExpr>(Expr)->getSubExpr(), Asm);
-    break;
-  }
-}
-
-void MipsMCExpr::fixELFSymbolsInTLSFixups(MCAssembler &Asm) const {
-  switch (getKind()) {
-  case MEK_None:
-  case MEK_Special:
-    llvm_unreachable("MEK_None and MEK_Special are invalid");
-    break;
-  case MEK_CALL_HI16:
-  case MEK_CALL_LO16:
-  case MEK_GOT:
-  case MEK_GOT_CALL:
-  case MEK_GOT_DISP:
-  case MEK_GOT_HI16:
-  case MEK_GOT_LO16:
-  case MEK_GOT_OFST:
-  case MEK_GOT_PAGE:
-  case MEK_GPREL:
-  case MEK_HI:
-  case MEK_HIGHER:
-  case MEK_HIGHEST:
-  case MEK_LO:
-  case MEK_NEG:
-  case MEK_PCREL_HI16:
-  case MEK_PCREL_LO16:
-    // If we do have nested target-specific expressions, they will be in
-    // a consecutive chain.
-    if (const MipsMCExpr *E = dyn_cast<const MipsMCExpr>(getSubExpr()))
-      E->fixELFSymbolsInTLSFixups(Asm);
-    break;
-  case MEK_DTPREL:
-  case MEK_DTPREL_HI:
-  case MEK_DTPREL_LO:
-  case MEK_TLSLDM:
-  case MEK_TLSGD:
-  case MEK_GOTTPREL:
-  case MEK_TPREL_HI:
-  case MEK_TPREL_LO:
-    fixELFSymbolsInTLSFixupsImpl(getSubExpr(), Asm);
-    break;
-  }
-}
-
 bool MipsMCExpr::isGpOff(MipsExprKind &Kind) const {
   if (getKind() == MEK_HI || getKind() == MEK_LO) {
     if (const MipsMCExpr *S1 = dyn_cast<const MipsMCExpr>(getSubExpr())) {

llvm/lib/Target/Mips/MCTargetDesc/MipsMCExpr.h

@@ -74,8 +74,6 @@ class MipsMCExpr : public MCTargetExpr {
     return getSubExpr()->findAssociatedFragment();
   }
 
-  void fixELFSymbolsInTLSFixups(MCAssembler &Asm) const override;
-
   static bool classof(const MCExpr *E) {
     return E->getKind() == MCExpr::Target;
   }

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCExpr.cpp

@@ -73,25 +73,17 @@ std::optional<int64_t> PPCMCExpr::evaluateAsInt64(int64_t Value) const {
 
 bool PPCMCExpr::evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
                                           const MCFixup *Fixup) const {
+  if (!Asm)
+    return false;
   if (!getSubExpr()->evaluateAsRelocatable(Res, Asm, Fixup))
     return false;
 
+  // The signedness of the result is dependent on the instruction operand. E.g.
+  // in addis 3,3,65535@l, 65535@l is signed. In the absence of information at
+  // parse time (!Asm), disable the folding.
   std::optional<int64_t> MaybeInt = evaluateAsInt64(Res.getConstant());
   if (Res.isAbsolute() && MaybeInt) {
-    int64_t Result = *MaybeInt;
-    bool IsHalf16 = Fixup && Fixup->getTargetKind() == PPC::fixup_ppc_half16;
-    bool IsHalf16DS =
-        Fixup && Fixup->getTargetKind() == PPC::fixup_ppc_half16ds;
-    bool IsHalf16DQ =
-        Fixup && Fixup->getTargetKind() == PPC::fixup_ppc_half16dq;
-    bool IsHalf = IsHalf16 || IsHalf16DS || IsHalf16DQ;
-
-    if (!IsHalf && Result >= 0x8000)
-      return false;
-    if ((IsHalf16DS && (Result & 0x3)) || (IsHalf16DQ && (Result & 0xf)))
-      return false;
-
-    Res = MCValue::get(Result);
+    Res = MCValue::get(*MaybeInt);
   } else {
     Res = MCValue::get(Res.getSymA(), Res.getSymB(), Res.getConstant(),
                        getKind());

llvm/lib/Target/RISCV/MCTargetDesc/RISCVELFObjectWriter.cpp

@@ -55,6 +55,17 @@ unsigned RISCVELFObjectWriter::getRelocType(MCContext &Ctx,
   unsigned Kind = Fixup.getTargetKind();
   if (Kind >= FirstLiteralRelocationKind)
     return Kind - FirstLiteralRelocationKind;
+
+  switch (Target.getRefKind()) {
+  case RISCVMCExpr::VK_RISCV_TPREL_HI:
+  case RISCVMCExpr::VK_RISCV_TLS_GOT_HI:
+  case RISCVMCExpr::VK_RISCV_TLS_GD_HI:
+  case RISCVMCExpr::VK_RISCV_TLSDESC_HI:
+    if (auto *S = Target.getSymA())
+      cast<MCSymbolELF>(S->getSymbol()).setType(ELF::STT_TLS);
+    break;
+  }
+
   if (IsPCRel) {
     switch (Kind) {
     default:

llvm/lib/Target/RISCV/MCTargetDesc/RISCVMCExpr.cpp

@@ -91,10 +91,7 @@ const MCFixup *RISCVMCExpr::getPCRelHiFixup(const MCFragment **DFOut) const {
 bool RISCVMCExpr::evaluateAsRelocatableImpl(MCValue &Res,
                                             const MCAssembler *Asm,
                                             const MCFixup *Fixup) const {
-  // Explicitly drop the layout and assembler to prevent any symbolic folding in
-  // the expression handling.  This is required to preserve symbolic difference
-  // expressions to emit the paired relocations.
-  if (!getSubExpr()->evaluateAsRelocatable(Res, nullptr, nullptr))
+  if (!getSubExpr()->evaluateAsRelocatable(Res, Asm, Fixup))
     return false;
 
   Res =
@@ -169,49 +166,6 @@ StringRef RISCVMCExpr::getVariantKindName(VariantKind Kind) {
   llvm_unreachable("Invalid ELF symbol kind");
 }
 
-static void fixELFSymbolsInTLSFixupsImpl(const MCExpr *Expr, MCAssembler &Asm) {
-  switch (Expr->getKind()) {
-  case MCExpr::Target:
-    llvm_unreachable("Can't handle nested target expression");
-    break;
-  case MCExpr::Constant:
-    break;
-
-  case MCExpr::Binary: {
-    const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
-    fixELFSymbolsInTLSFixupsImpl(BE->getLHS(), Asm);
-    fixELFSymbolsInTLSFixupsImpl(BE->getRHS(), Asm);
-    break;
-  }
-
-  case MCExpr::SymbolRef: {
-    // We're known to be under a TLS fixup, so any symbol should be
-    // modified. There should be only one.
-    const MCSymbolRefExpr &SymRef = *cast<MCSymbolRefExpr>(Expr);
-    cast<MCSymbolELF>(SymRef.getSymbol()).setType(ELF::STT_TLS);
-    break;
-  }
-
-  case MCExpr::Unary:
-    fixELFSymbolsInTLSFixupsImpl(cast<MCUnaryExpr>(Expr)->getSubExpr(), Asm);
-    break;
-  }
-}
-
-void RISCVMCExpr::fixELFSymbolsInTLSFixups(MCAssembler &Asm) const {
-  switch (getKind()) {
-  default:
-    return;
-  case VK_RISCV_TPREL_HI:
-  case VK_RISCV_TLS_GOT_HI:
-  case VK_RISCV_TLS_GD_HI:
-  case VK_RISCV_TLSDESC_HI:
-    break;
-  }
-
-  fixELFSymbolsInTLSFixupsImpl(getSubExpr(), Asm);
-}
-
 bool RISCVMCExpr::evaluateAsConstant(int64_t &Res) const {
   MCValue Value;
   if (Kind != VK_RISCV_LO && Kind != VK_RISCV_HI)

llvm/lib/Target/RISCV/MCTargetDesc/RISCVMCExpr.h

@@ -76,8 +76,6 @@ class RISCVMCExpr : public MCTargetExpr {
     return getSubExpr()->findAssociatedFragment();
   }
 
-  void fixELFSymbolsInTLSFixups(MCAssembler &Asm) const override;
-
   bool evaluateAsConstant(int64_t &Res) const;
 
   static bool classof(const MCExpr *E) {

llvm/lib/Target/Sparc/MCTargetDesc/SparcELFObjectWriter.cpp

@@ -46,6 +46,30 @@ unsigned SparcELFObjectWriter::getRelocType(MCContext &Ctx,
   if (Kind >= FirstLiteralRelocationKind)
     return Kind - FirstLiteralRelocationKind;
 
+  switch (Target.getRefKind()) {
+  case SparcMCExpr::VK_Sparc_TLS_GD_HI22:
+  case SparcMCExpr::VK_Sparc_TLS_GD_LO10:
+  case SparcMCExpr::VK_Sparc_TLS_GD_ADD:
+  case SparcMCExpr::VK_Sparc_TLS_LDM_HI22:
+  case SparcMCExpr::VK_Sparc_TLS_LDM_LO10:
+  case SparcMCExpr::VK_Sparc_TLS_LDM_ADD:
+  case SparcMCExpr::VK_Sparc_TLS_LDO_HIX22:
+  case SparcMCExpr::VK_Sparc_TLS_LDO_LOX10:
+  case SparcMCExpr::VK_Sparc_TLS_LDO_ADD:
+  case SparcMCExpr::VK_Sparc_TLS_IE_HI22:
+  case SparcMCExpr::VK_Sparc_TLS_IE_LO10:
+  case SparcMCExpr::VK_Sparc_TLS_IE_LD:
+  case SparcMCExpr::VK_Sparc_TLS_IE_LDX:
+  case SparcMCExpr::VK_Sparc_TLS_IE_ADD:
+  case SparcMCExpr::VK_Sparc_TLS_LE_HIX22:
+  case SparcMCExpr::VK_Sparc_TLS_LE_LOX10:
+    if (auto *S = Target.getSymA())
+      cast<MCSymbolELF>(S->getSymbol()).setType(ELF::STT_TLS);
+    break;
+  default:
+    break;
+  }
+
   if (const SparcMCExpr *SExpr = dyn_cast<SparcMCExpr>(Fixup.getValue())) {
     if (SExpr->getKind() == SparcMCExpr::VK_Sparc_R_DISP32)
       return ELF::R_SPARC_DISP32;