merge main into amd-staging (llvm#2443)

Author: z1-cciauto

flang/test/Driver/prefer-vector-width.f90

@@ -9,8 +9,8 @@
 subroutine func
 end subroutine func
 
-! CHECK-DEF-NOT: attributes #0 = { "prefer-vector-width"={{.*}} }
-! CHECK-NONE: attributes #0 = { "prefer-vector-width"="none" }
-! CHECK-128: attributes #0 = { "prefer-vector-width"="128" }
-! CHECK-256: attributes #0 = { "prefer-vector-width"="256" }
+! CHECK-DEF-NOT: attributes #0 = { "prefer-vector-width"={{.*}}
+! CHECK-NONE: attributes #0 = { "prefer-vector-width"="none"
+! CHECK-128: attributes #0 = { "prefer-vector-width"="128"
+! CHECK-256: attributes #0 = { "prefer-vector-width"="256"
 ! CHECK-INVALID:error: invalid value 'xxx' in '-mprefer-vector-width=xxx'

llvm/include/llvm/MC/MCAssembler.h

@@ -71,6 +71,8 @@ class MCAssembler {
 
   SmallVector<const MCSymbol *, 0> Symbols;
 
+  mutable SmallVector<std::pair<SMLoc, std::string>, 0> PendingErrors;
+
   MCDwarfLineTableParams LTParams;
 
   /// The set of function symbols for which a .thumb_func directive has
@@ -230,6 +232,10 @@ class MCAssembler {
                             uint64_t FSize) const;
 
   void reportError(SMLoc L, const Twine &Msg) const;
+  // Record pending errors during layout iteration, as they may go away once the
+  // layout is finalized.
+  void recordError(SMLoc L, const Twine &Msg) const;
+  void flushPendingErrors() const;
 
   void dump() const;
 };

llvm/lib/MC/MCAssembler.cpp

@@ -217,12 +217,12 @@ uint64_t MCAssembler::computeFragmentSize(const MCFragment &F) const {
     auto &FF = cast<MCFillFragment>(F);
     int64_t NumValues = 0;
     if (!FF.getNumValues().evaluateKnownAbsolute(NumValues, *this)) {
-      reportError(FF.getLoc(), "expected assembly-time absolute expression");
+      recordError(FF.getLoc(), "expected assembly-time absolute expression");
       return 0;
     }
     int64_t Size = NumValues * FF.getValueSize();
     if (Size < 0) {
-      reportError(FF.getLoc(), "invalid number of bytes");
+      recordError(FF.getLoc(), "invalid number of bytes");
       return 0;
     }
     return Size;
@@ -266,7 +266,7 @@ uint64_t MCAssembler::computeFragmentSize(const MCFragment &F) const {
     const MCOrgFragment &OF = cast<MCOrgFragment>(F);
     MCValue Value;
     if (!OF.getOffset().evaluateAsValue(Value, *this)) {
-      reportError(OF.getLoc(), "expected assembly-time absolute expression");
+      recordError(OF.getLoc(), "expected assembly-time absolute expression");
       return 0;
     }
 
@@ -275,14 +275,14 @@ uint64_t MCAssembler::computeFragmentSize(const MCFragment &F) const {
     if (const auto *SA = Value.getAddSym()) {
       uint64_t Val;
       if (!getSymbolOffset(*SA, Val)) {
-        reportError(OF.getLoc(), "expected absolute expression");
+        recordError(OF.getLoc(), "expected absolute expression");
         return 0;
       }
       TargetLocation += Val;
     }
     int64_t Size = TargetLocation - FragmentOffset;
     if (Size < 0 || Size >= 0x40000000) {
-      reportError(OF.getLoc(), "invalid .org offset '" + Twine(TargetLocation) +
+      recordError(OF.getLoc(), "invalid .org offset '" + Twine(TargetLocation) +
                                    "' (at offset '" + Twine(FragmentOffset) +
                                    "')");
       return 0;
@@ -825,6 +825,7 @@ void MCAssembler::writeSectionData(raw_ostream &OS,
   for (const MCFragment &F : *Sec)
     writeFragment(OS, *this, F);
 
+  flushPendingErrors();
   assert(getContext().hadError() ||
          OS.tell() - Start == getSectionAddressSize(*Sec));
 }
@@ -878,6 +879,8 @@ void MCAssembler::layout() {
   // Finalize the layout, including fragment lowering.
   getBackend().finishLayout(*this);
 
+  flushPendingErrors();
+
   DEBUG_WITH_TYPE("mc-dump", {
       errs() << "assembler backend - final-layout\n--\n";
       dump(); });
@@ -968,6 +971,7 @@ void MCAssembler::Finish() {
   stats::ObjectBytes += getWriter().writeObject();
 
   HasLayout = false;
+  assert(PendingErrors.empty());
 }
 
 bool MCAssembler::fixupNeedsRelaxation(const MCFixup &Fixup,
@@ -1222,6 +1226,7 @@ bool MCAssembler::relaxFragment(MCFragment &F) {
 
 bool MCAssembler::layoutOnce() {
   ++stats::RelaxationSteps;
+  PendingErrors.clear();
 
   bool Changed = false;
   for (MCSection &Sec : *this)
@@ -1235,6 +1240,16 @@ void MCAssembler::reportError(SMLoc L, const Twine &Msg) const {
   getContext().reportError(L, Msg);
 }
 
+void MCAssembler::recordError(SMLoc Loc, const Twine &Msg) const {
+  PendingErrors.emplace_back(Loc, Msg.str());
+}
+
+void MCAssembler::flushPendingErrors() const {
+  for (auto &Err : PendingErrors)
+    reportError(Err.first, Err.second);
+  PendingErrors.clear();
+}
+
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void MCAssembler::dump() const{
   raw_ostream &OS = errs();

llvm/lib/MC/MCExpr.cpp

@@ -475,14 +475,6 @@ bool MCExpr::evaluateAsRelocatable(MCValue &Res, const MCAssembler *Asm) const {
 bool MCExpr::evaluateAsValue(MCValue &Res, const MCAssembler &Asm) const {
   return evaluateAsRelocatableImpl(Res, &Asm, true);
 }
-static bool canExpand(const MCSymbol &Sym, bool InSet) {
-  if (Sym.isWeakExternal())
-    return false;
-
-  if (InSet)
-    return true;
-  return !Sym.isInSection();
-}
 
 bool MCExpr::evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
                                        bool InSet) const {
@@ -500,7 +492,10 @@ bool MCExpr::evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
     const auto Kind = SRE->getKind();
     bool Layout = Asm && Asm->hasLayout();
 
-    // Evaluate recursively if this is a variable.
+    // If the symbol is equated, resolve the inner expression.
+    // However, when two IMAGE_WEAK_EXTERN_ANTI_DEPENDENCY symbols reference
+    // each other, we retain the equated symbol to avoid a cyclic definition
+    // error.
     if (Sym.isResolving()) {
       if (Asm && Asm->hasFinalLayout()) {
         Asm->getContext().reportError(
@@ -511,13 +506,20 @@ bool MCExpr::evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
       return false;
     }
     if (Sym.isVariable() && (Kind == MCSymbolRefExpr::VK_None || Layout) &&
-        canExpand(Sym, InSet)) {
+        !Sym.isWeakExternal()) {
       Sym.setIsResolving(true);
       auto _ = make_scope_exit([&] { Sym.setIsResolving(false); });
       bool IsMachO =
           Asm && Asm->getContext().getAsmInfo()->hasSubsectionsViaSymbols();
-      if (Sym.getVariableValue()->evaluateAsRelocatableImpl(Res, Asm,
-                                                            InSet || IsMachO)) {
+      if (!Sym.getVariableValue()->evaluateAsRelocatableImpl(Res, Asm,
+                                                             InSet || IsMachO))
+        return false;
+      // When generating relocations, if Sym resolves to a symbol relative to a
+      // section, relocations are generated against Sym. Treat label differences
+      // as constants.
+      auto *A = Res.getAddSym();
+      auto *B = Res.getSubSym();
+      if (InSet || !(A && !B && A->isInSection())) {
         if (Kind != MCSymbolRefExpr::VK_None) {
           if (Res.isAbsolute()) {
             Res = MCValue::get(&Sym, nullptr, 0, Kind);
@@ -534,8 +536,6 @@ bool MCExpr::evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
         if (!IsMachO)
           return true;
 
-        auto *A = Res.getAddSym();
-        auto *B = Res.getSubSym();
         // FIXME: This is small hack. Given
         // a = b + 4
         // .long a
@@ -548,8 +548,6 @@ bool MCExpr::evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
         // Allows aliases with zero offset.
         if (Res.getConstant() == 0 && (!A || !B))
           return true;
-      } else {
-        return false;
       }
     }
 

llvm/lib/MC/MCParser/AsmParser.cpp

@@ -6438,6 +6438,11 @@ bool parseAssignmentExpression(StringRef Name, bool allow_redef,
     return Parser.TokError("missing expression");
   if (Parser.parseEOL())
     return true;
+  // Relocation specifiers are not permitted. For now, handle just
+  // MCSymbolRefExpr.
+  if (auto *S = dyn_cast<MCSymbolRefExpr>(Value); S && S->getSpecifier())
+    return Parser.Error(
+        EqualLoc, "relocation specifier not permitted in symbol equating");
 
   // Validate that the LHS is allowed to be a variable (either it has not been
   // used as a symbol, or it is an absolute symbol).

llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp

@@ -916,9 +916,6 @@ void X86AsmBackend::finishLayout(MCAssembler const &Asm) const {
         continue;
       }
 
-#ifndef NDEBUG
-      const uint64_t OrigOffset = Asm.getFragmentOffset(F);
-#endif
       const uint64_t OrigSize = Asm.computeFragmentSize(F);
 
       // To keep the effects local, prefer to relax instructions closest to
@@ -949,14 +946,6 @@ void X86AsmBackend::finishLayout(MCAssembler const &Asm) const {
       if (F.getKind() == MCFragment::FT_BoundaryAlign)
         cast<MCBoundaryAlignFragment>(F).setSize(RemainingSize);
 
-#ifndef NDEBUG
-      const uint64_t FinalOffset = Asm.getFragmentOffset(F);
-      const uint64_t FinalSize = Asm.computeFragmentSize(F);
-      assert(OrigOffset + OrigSize == FinalOffset + FinalSize &&
-             "can't move start of next fragment!");
-      assert(FinalSize == RemainingSize && "inconsistent size computation?");
-#endif
-
       // If we're looking at a boundary align, make sure we don't try to pad
       // its target instructions for some following directive.  Doing so would
       // break the alignment of the current boundary align.
@@ -971,10 +960,8 @@ void X86AsmBackend::finishLayout(MCAssembler const &Asm) const {
   }
 
   // The layout is done. Mark every fragment as valid.
-  for (MCSection &Section : Asm) {
+  for (MCSection &Section : Asm)
     Asm.getFragmentOffset(*Section.curFragList()->Tail);
-    Asm.computeFragmentSize(*Section.curFragList()->Tail);
-  }
 }
 
 unsigned X86AsmBackend::getMaximumNopSize(const MCSubtargetInfo &STI) const {

llvm/test/Analysis/LoopAccessAnalysis/no-dep-via-loop-guards.ll

@@ -349,3 +349,90 @@ loop:
 exit:
   ret void
 }
+
+; TODO Should be able to determine no-dep, same as @nodep_via_logical_and_2.
+define void @nodep_via_logical_and_1(ptr %A, i32 %index, i32 %n) {
+; CHECK-LABEL: 'nodep_via_logical_and_1'
+; CHECK-NEXT:    loop:
+; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
+; CHECK-NEXT:  Unknown data dependence.
+; CHECK-NEXT:      Dependences:
+; CHECK-NEXT:        Unknown:
+; CHECK-NEXT:            %0 = load double, ptr %gep.load, align 8 ->
+; CHECK-NEXT:            store double %0, ptr %gep.store, align 8
+; CHECK-EMPTY:
+; CHECK-NEXT:      Run-time memory checks:
+; CHECK-NEXT:      Grouped accesses:
+; CHECK-EMPTY:
+; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT:      SCEV assumptions:
+; CHECK-EMPTY:
+; CHECK-NEXT:      Expressions re-written:
+;
+entry:
+  %pre.0 = icmp sgt i32 %index, 0
+  %pre.1 = icmp slt i32 %index, %n
+  %and.pre = select i1 %pre.1, i1 %pre.0, i1 false
+  br i1 %and.pre, label %ph, label %exit
+
+ph:
+  %idx.1 = add i32 %index, 1
+  %start = zext i32 %idx.1 to i64
+  br label %loop
+
+loop:
+  %iv = phi i64 [ %start, %ph ], [ %iv.next, %loop ]
+  %gep.load = getelementptr double, ptr %A, i64 %iv
+  %1 = load double, ptr %gep.load, align 8
+  %index.ext = zext i32 %index to i64
+  %gep.store = getelementptr double, ptr %A, i64 %index.ext
+  store double %1, ptr %gep.store, align 8
+  %iv.next = add i64 %iv, 1
+  %t = trunc i64 %iv to i32
+  %ec = icmp slt i32 %t, 1
+  br i1 %ec, label %loop, label %exit
+
+exit:
+  ret void
+}
+
+; Same as nodep_via_logical_and_1 but with different operand order of the logical and.
+define void @nodep_via_logical_and_2(ptr %A, i32 %index, i32 %n) {
+; CHECK-LABEL: 'nodep_via_logical_and_2'
+; CHECK-NEXT:    loop:
+; CHECK-NEXT:      Memory dependences are safe
+; CHECK-NEXT:      Dependences:
+; CHECK-NEXT:      Run-time memory checks:
+; CHECK-NEXT:      Grouped accesses:
+; CHECK-EMPTY:
+; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT:      SCEV assumptions:
+; CHECK-EMPTY:
+; CHECK-NEXT:      Expressions re-written:
+;
+entry:
+  %pre.0 = icmp sgt i32 %index, 0
+  %pre.1 = icmp slt i32 %index, %n
+  %and.pre = select i1 %pre.0, i1 %pre.1, i1 false
+  br i1 %and.pre, label %ph, label %exit
+
+ph:
+  %idx.1 = add i32 %index, 1
+  %start = zext i32 %idx.1 to i64
+  br label %loop
+
+loop:
+  %iv = phi i64 [ %start, %ph ], [ %iv.next, %loop ]
+  %gep.load = getelementptr double, ptr %A, i64 %iv
+  %1 = load double, ptr %gep.load, align 8
+  %index.ext = zext i32 %index to i64
+  %gep.store = getelementptr double, ptr %A, i64 %index.ext
+  store double %1, ptr %gep.store, align 8
+  %iv.next = add i64 %iv, 1
+  %t = trunc i64 %iv to i32
+  %ec = icmp slt i32 %t, 1
+  br i1 %ec, label %loop, label %exit
+
+exit:
+  ret void
+}