Distinct Attributes.

.git-blame-ignore-revs

@@ -55,3 +55,6 @@ dd3c26a045c081620375a878159f536758baba6e
 f98ee40f4b5d7474fc67e82824bf6abbaedb7b1c
 2238dcc39358353cac21df75c3c3286ab20b8f53
 f9008e6366c2496b1ca1785b891d5578174ad63e
+
+# [libc++][NFC] Apply clang-format on large parts of the code base
+5aa03b648b827128d439f705cd7d57d59673741d

bolt/include/bolt/Core/BinarySection.h

@@ -59,7 +59,7 @@ class BinarySection {
 
   // Relocations associated with this section. Relocation offsets are
   // wrt. to the original section address and size.
-  using RelocationSetType = std::set<Relocation, std::less<>>;
+  using RelocationSetType = std::multiset<Relocation, std::less<>>;
   RelocationSetType Relocations;
 
   // Dynamic relocations associated with this section. Relocation offsets are
@@ -345,7 +345,8 @@ class BinarySection {
   bool removeRelocationAt(uint64_t Offset) {
     auto Itr = Relocations.find(Offset);
     if (Itr != Relocations.end()) {
-      Relocations.erase(Itr);
+      auto End = Relocations.upper_bound(Offset);
+      Relocations.erase(Itr, End);
       return true;
     }
     return false;

bolt/include/bolt/Core/Relocation.h

@@ -14,10 +14,11 @@
 #ifndef BOLT_CORE_RELOCATION_H
 #define BOLT_CORE_RELOCATION_H
 
+#include "llvm/MC/MCExpr.h"
+#include "llvm/MC/MCStreamer.h"
 #include "llvm/TargetParser/Triple.h"
 
 namespace llvm {
-class MCStreamer;
 class MCSymbol;
 class raw_ostream;
 
@@ -122,8 +123,36 @@ struct Relocation {
   /// responsible for setting the position correctly.
   size_t emit(MCStreamer *Streamer) const;
 
+  /// Emit a group of composed relocations. All relocations must have the same
+  /// offset. If std::distance(Begin, End) == 1, this is equivalent to
+  /// Begin->emit(Streamer).
+  template <typename RelocIt>
+  static size_t emit(RelocIt Begin, RelocIt End, MCStreamer *Streamer) {
+    if (Begin == End)
+      return 0;
+
+    const MCExpr *Value = nullptr;
+
+    for (auto RI = Begin; RI != End; ++RI) {
+      assert(RI->Offset == Begin->Offset &&
+             "emitting composed relocations with different offsets");
+      Value = RI->createExpr(Streamer, Value);
+    }
+
+    assert(Value && "failed to create relocation value");
+    auto Size = std::prev(End)->getSize();
+    Streamer->emitValue(Value, Size);
+    return Size;
+  }
+
   /// Print a relocation to \p OS.
   void print(raw_ostream &OS) const;
+
+private:
+  const MCExpr *createExpr(MCStreamer *Streamer) const;
+  const MCExpr *createExpr(MCStreamer *Streamer,
+                           const MCExpr *RetainedValue) const;
+  static MCBinaryExpr::Opcode getComposeOpcodeFor(uint64_t Type);
 };
 
 /// Relocation ordering by offset.

bolt/lib/Core/BinarySection.cpp

@@ -90,23 +90,46 @@ void BinarySection::emitAsData(MCStreamer &Streamer,
     Streamer.emitBytes(SectionContents);
   } else {
     uint64_t SectionOffset = 0;
-    for (const Relocation &Relocation : relocations()) {
-      assert(Relocation.Offset < SectionContents.size() && "overflow detected");
+    for (auto RI = Relocations.begin(), RE = Relocations.end(); RI != RE;) {
+      auto RelocationOffset = RI->Offset;
+      assert(RelocationOffset < SectionContents.size() && "overflow detected");
+
+      if (SectionOffset < RelocationOffset) {
+        Streamer.emitBytes(SectionContents.substr(
+            SectionOffset, RelocationOffset - SectionOffset));
+        SectionOffset = RelocationOffset;
+      }
+
+      // Get iterators to all relocations with the same offset. Usually, there
+      // is only one such relocation but there can be more for composed
+      // relocations.
+      auto ROI = RI;
+      auto ROE = Relocations.upper_bound(RelocationOffset);
+
+      // Start from the next offset on the next iteration.
+      RI = ROE;
+
       // Skip undefined symbols.
-      if (BC.UndefinedSymbols.count(Relocation.Symbol))
+      auto HasUndefSym = [this](const auto &Relocation) {
+        return BC.UndefinedSymbols.count(Relocation.Symbol);
+      };
+
+      if (std::any_of(ROI, ROE, HasUndefSym))
         continue;
-      if (SectionOffset < Relocation.Offset) {
-        Streamer.emitBytes(SectionContents.substr(
-            SectionOffset, Relocation.Offset - SectionOffset));
-        SectionOffset = Relocation.Offset;
+
+#ifndef NDEBUG
+      for (const auto &Relocation : make_range(ROI, ROE)) {
+        LLVM_DEBUG(
+            dbgs() << "BOLT-DEBUG: emitting relocation for symbol "
+                   << (Relocation.Symbol ? Relocation.Symbol->getName()
+                                         : StringRef("<none>"))
+                   << " at offset 0x" << Twine::utohexstr(Relocation.Offset)
+                   << " with size "
+                   << Relocation::getSizeForType(Relocation.Type) << '\n');
       }
-      LLVM_DEBUG(dbgs() << "BOLT-DEBUG: emitting relocation for symbol "
-                        << (Relocation.Symbol ? Relocation.Symbol->getName()
-                                              : StringRef("<none>"))
-                        << " at offset 0x"
-                        << Twine::utohexstr(Relocation.Offset) << " with size "
-                        << Relocation::getSizeForType(Relocation.Type) << '\n');
-      size_t RelocationSize = Relocation.emit(&Streamer);
+#endif
+
+      size_t RelocationSize = Relocation::emit(ROI, ROE, &Streamer);
       SectionOffset += RelocationSize;
     }
     assert(SectionOffset <= SectionContents.size() && "overflow error");
@@ -221,9 +244,7 @@ BinarySection::reorderRelocations(bool Inplace) const {
     assert(NewRel.Offset < getSize());
     LLVM_DEBUG(dbgs() << "BOLT-DEBUG: moving " << Rel << " -> " << NewRel
                       << "\n");
-    auto Res = NewRelocations.emplace(std::move(NewRel));
-    (void)Res;
-    assert(Res.second && "Can't overwrite existing relocation");
+    NewRelocations.emplace(std::move(NewRel));
   }
   return NewRelocations;
 }

bolt/lib/Core/Relocation.cpp

@@ -817,39 +817,48 @@ uint64_t Relocation::getRelative() {
 
 size_t Relocation::emit(MCStreamer *Streamer) const {
   const size_t Size = getSizeForType(Type);
+  const auto *Value = createExpr(Streamer);
+  Streamer->emitValue(Value, Size);
+  return Size;
+}
+
+const MCExpr *Relocation::createExpr(MCStreamer *Streamer) const {
   MCContext &Ctx = Streamer->getContext();
+  const MCExpr *Value = nullptr;
+
+  if (Symbol && Addend) {
+    Value = MCBinaryExpr::createAdd(MCSymbolRefExpr::create(Symbol, Ctx),
+                                    MCConstantExpr::create(Addend, Ctx), Ctx);
+  } else if (Symbol) {
+    Value = MCSymbolRefExpr::create(Symbol, Ctx);
+  } else {
+    Value = MCConstantExpr::create(Addend, Ctx);
+  }
+
   if (isPCRelative(Type)) {
     MCSymbol *TempLabel = Ctx.createNamedTempSymbol();
     Streamer->emitLabel(TempLabel);
-    const MCExpr *Value = nullptr;
-    if (Symbol) {
-      Value = MCSymbolRefExpr::create(Symbol, Ctx);
-      if (Addend) {
-        Value = MCBinaryExpr::createAdd(
-            Value, MCConstantExpr::create(Addend, Ctx), Ctx);
-      }
-    } else {
-      Value = MCConstantExpr::create(Addend, Ctx);
-    }
     Value = MCBinaryExpr::createSub(
         Value, MCSymbolRefExpr::create(TempLabel, Ctx), Ctx);
-    Streamer->emitValue(Value, Size);
-
-    return Size;
   }
 
-  if (Symbol && Addend) {
-    auto Value =
-        MCBinaryExpr::createAdd(MCSymbolRefExpr::create(Symbol, Ctx),
-                                MCConstantExpr::create(Addend, Ctx), Ctx);
-    Streamer->emitValue(Value, Size);
-  } else if (Symbol) {
-    Streamer->emitSymbolValue(Symbol, Size);
-  } else {
-    Streamer->emitIntValue(Addend, Size);
+  return Value;
+}
+
+const MCExpr *Relocation::createExpr(MCStreamer *Streamer,
+                                     const MCExpr *RetainedValue) const {
+  const auto *Value = createExpr(Streamer);
+
+  if (RetainedValue) {
+    Value = MCBinaryExpr::create(getComposeOpcodeFor(Type), RetainedValue,
+                                 Value, Streamer->getContext());
   }
 
-  return Size;
+  return Value;
+}
+
+MCBinaryExpr::Opcode Relocation::getComposeOpcodeFor(uint64_t Type) {
+  llvm_unreachable("not implemented");
 }
 
 #define ELF_RELOC(name, value) #name,

clang-tools-extra/include-cleaner/lib/WalkAST.cpp

@@ -214,6 +214,10 @@ class ASTWalker : public RecursiveASTVisitor<ASTWalker> {
     return true;
   }
   bool VisitVarDecl(VarDecl *VD) {
+    // Ignore the parameter decl itself (its children were handled elsewhere),
+    // as they don't contribute to the main-file #include.
+    if (llvm::isa<ParmVarDecl>(VD))
+      return true;
     // Mark declaration from definition as it needs type-checking.
     if (VD->isThisDeclarationADefinition())
       report(VD->getLocation(), VD);

clang-tools-extra/include-cleaner/tool/IncludeCleaner.cpp

@@ -108,10 +108,18 @@ class Action : public clang::ASTFrontendAction {
   }
 
   void EndSourceFile() override {
+    const auto &SM = getCompilerInstance().getSourceManager();
+    if (SM.getDiagnostics().hasUncompilableErrorOccurred()) {
+      llvm::errs()
+          << "Skipping file " << getCurrentFile()
+          << " due to compiler errors. clang-include-cleaner expects to "
+             "work on compilable source code.\n";
+      return;
+    }
+
     if (!HTMLReportPath.empty())
       writeHTML();
 
-    const auto &SM = getCompilerInstance().getSourceManager();
     auto &HS = getCompilerInstance().getPreprocessor().getHeaderSearchInfo();
     llvm::StringRef Path =
         SM.getFileEntryForID(SM.getMainFileID())->tryGetRealPathName();

clang-tools-extra/include-cleaner/unittests/AnalysisTest.cpp

@@ -91,7 +91,8 @@ TEST_F(WalkUsedTest, Basic) {
   #include "header.h"
   #include "private.h"
 
-  void $bar^bar($private^Private $p^p) {
+  // No reference reported for the Parameter "p".
+  void $bar^bar($private^Private p) {
     $foo^foo();
     std::$vector^vector $vconstructor^$v^v;
     $builtin^__builtin_popcount(1);
@@ -120,7 +121,6 @@ TEST_F(WalkUsedTest, Basic) {
       offsetToProviders(AST, SM),
       UnorderedElementsAre(
           Pair(Code.point("bar"), UnorderedElementsAre(MainFile)),
-          Pair(Code.point("p"), UnorderedElementsAre(MainFile)),
           Pair(Code.point("private"),
                UnorderedElementsAre(PublicFile, PrivateFile)),
           Pair(Code.point("foo"), UnorderedElementsAre(HeaderFile)),

clang/docs/LanguageExtensions.rst

@@ -645,6 +645,10 @@ Unless specified otherwise operation(±0) = ±0 and operation(±infinity) = ±in
                                              rounding halfway cases to even (that is, to the nearest value
                                              that is an even integer), regardless of the current rounding
                                              direction.
+ T __builtin_elementwise_round(T x)          round x to the nearest  integer value in floating point format,      floating point types
+                                             rounding halfway cases away from zero, regardless of the
+                                             current rounding direction. May raise floating-point
+                                             exceptions.
  T __builtin_elementwise_trunc(T x)          return the integral value nearest to but no larger in            floating point types
                                              magnitude than x
  T __builtin_elementwise_canonicalize(T x)   return the platform specific canonical encoding                  floating point types

clang/docs/ReleaseNotes.rst

@@ -228,6 +228,10 @@ Non-comprehensive list of changes in this release
   variable as a way to disable color diagnostics.
 - Clang now supports ``__builtin_isfpclass``, which checks if the specified
   floating-point value falls into any of the specified data classes.
+- Added ``__builtin_elementwise_round`` for  builtin for floating
+  point types. This allows access to ``llvm.round`` for
+  arbitrary floating-point and vector of floating-point types.
+
 
 New Compiler Flags
 ------------------

clang/include/clang/Basic/Builtins.def

@@ -687,6 +687,7 @@ BUILTIN(__builtin_elementwise_log, "v.", "nct")
 BUILTIN(__builtin_elementwise_log2, "v.", "nct")
 BUILTIN(__builtin_elementwise_log10, "v.", "nct")
 BUILTIN(__builtin_elementwise_roundeven, "v.", "nct")
+BUILTIN(__builtin_elementwise_round, "v.", "nct")
 BUILTIN(__builtin_elementwise_sin, "v.", "nct")
 BUILTIN(__builtin_elementwise_trunc, "v.", "nct")
 BUILTIN(__builtin_elementwise_canonicalize, "v.", "nct")

clang/include/clang/CodeGen/CodeGenAction.h

@@ -53,6 +53,9 @@ class CodeGenAction : public ASTFrontendAction {
 
   std::unique_ptr<llvm::Module> loadModule(llvm::MemoryBufferRef MBRef);
 
+  /// Load bitcode modules to link into our module from the options.
+  bool loadLinkModules(CompilerInstance &CI);
+
 protected:
   /// Create a new code generation action.  If the optional \p _VMContext
   /// parameter is supplied, the action uses it without taking ownership,

clang/include/clang/Driver/Options.td

@@ -2266,10 +2266,8 @@ defm xray_function_index : BoolFOption<"xray-function-index",
           " expense of single-function patching performance">>;
 
 def fxray_link_deps : Flag<["-"], "fxray-link-deps">, Group<f_Group>,
-  Flags<[CC1Option]>,
-  HelpText<"Tells clang to add the link dependencies for XRay.">;
-def fnoxray_link_deps : Flag<["-"], "fnoxray-link-deps">, Group<f_Group>,
-  Flags<[CC1Option]>;
+  HelpText<"Link XRay runtime library when -fxray-instrument is specified (default)">;
+def fno_xray_link_deps : Flag<["-"], "fno-xray-link-deps">, Group<f_Group>;
 
 def fxray_instrumentation_bundle :
   Joined<["-"], "fxray-instrumentation-bundle=">,

clang/include/clang/Serialization/ASTBitCodes.h

@@ -1099,14 +1099,22 @@ enum PredefinedTypeIDs {
 // \brief WebAssembly reference types with auto numeration
 #define WASM_TYPE(Name, Id, SingletonId) PREDEF_TYPE_##Id##_ID,
 #include "clang/Basic/WebAssemblyReferenceTypes.def"
+  // Sentinel value. Considered a predefined type but not useable as one.
+  PREDEF_TYPE_LAST_ID
 };
 
 /// The number of predefined type IDs that are reserved for
 /// the PREDEF_TYPE_* constants.
 ///
 /// Type IDs for non-predefined types will start at
 /// NUM_PREDEF_TYPE_IDs.
-const unsigned NUM_PREDEF_TYPE_IDS = 300;
+const unsigned NUM_PREDEF_TYPE_IDS = 500;
+
+// Ensure we do not overrun the predefined types we reserved
+// in the enum PredefinedTypeIDs above.
+static_assert(PREDEF_TYPE_LAST_ID < NUM_PREDEF_TYPE_IDS,
+              "Too many enumerators in PredefinedTypeIDs. Review the value of "
+              "NUM_PREDEF_TYPE_IDS");
 
 /// Record codes for each kind of type.
 ///

clang/lib/CodeGen/CGBuiltin.cpp

@@ -3194,6 +3194,9 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
   case Builtin::BI__builtin_elementwise_roundeven:
     return RValue::get(emitUnaryBuiltin(*this, E, llvm::Intrinsic::roundeven,
                                         "elt.roundeven"));
+  case Builtin::BI__builtin_elementwise_round:
+    return RValue::get(emitUnaryBuiltin(*this, E, llvm::Intrinsic::round,
+                                        "elt.round"));
   case Builtin::BI__builtin_elementwise_sin:
     return RValue::get(
         emitUnaryBuiltin(*this, E, llvm::Intrinsic::sin, "elt.sin"));