Merge branch 'amd-staging' of ssh://gerrit-git.amd.com:29418/lightnin…

…g/ec/llvm-project into amd-staging

bolt/include/bolt/Rewrite/RewriteInstance.h

@@ -422,6 +422,10 @@ class RewriteInstance {
  /// Section name used for extra BOLT code in addition to .text.
  static StringRef getBOLTTextSectionName() { return ".bolt.text"; }
 
+ /// Symbol markers for BOLT reserved area.
+ static StringRef getBOLTReservedStart() { return "__bolt_reserved_start"; }
+ static StringRef getBOLTReservedEnd() { return "__bolt_reserved_end"; }
+
  /// Common section names.
  static StringRef getEHFrameSectionName() { return ".eh_frame"; }
  static StringRef getEHFrameHdrSectionName() { return ".eh_frame_hdr"; }

bolt/lib/Rewrite/RewriteInstance.cpp

@@ -1063,6 +1063,11 @@ void RewriteInstance::discoverFileObjects() {
  continue;
  }
 
+ if (SymName == getBOLTReservedStart() || SymName == getBOLTReservedEnd()) {
+ registerName(SymbolSize);
+ continue;
+ }
+
  LLVM_DEBUG(dbgs() << "BOLT-DEBUG: considering symbol " << UniqueName
  << " for function\n");
 
@@ -3594,6 +3599,26 @@ void RewriteInstance::updateMetadata() {
 void RewriteInstance::mapFileSections(BOLTLinker::SectionMapper MapSection) {
  BC->deregisterUnusedSections();
 
+ // Check if the input has a space reserved for BOLT.
+ BinaryData *StartBD = BC->getBinaryDataByName(getBOLTReservedStart());
+ BinaryData *EndBD = BC->getBinaryDataByName(getBOLTReservedEnd());
+ if (!StartBD != !EndBD) {
+ BC->errs() << "BOLT-ERROR: one of the symbols is missing from the binary: "
+ << getBOLTReservedStart() << ", " << getBOLTReservedEnd()
+ << '\n';
+ exit(1);
+ }
+
+ if (StartBD) {
+ PHDRTableOffset = 0;
+ PHDRTableAddress = 0;
+ NewTextSegmentAddress = 0;
+ NewTextSegmentOffset = 0;
+ NextAvailableAddress = StartBD->getAddress();
+ BC->outs()
+ << "BOLT-INFO: using reserved space for allocating new sections\n";
+ }
+
  // If no new .eh_frame was written, remove relocated original .eh_frame.
  BinarySection *RelocatedEHFrameSection =
  getSection(".relocated" + getEHFrameSectionName());
@@ -3613,6 +3638,18 @@ void RewriteInstance::mapFileSections(BOLTLinker::SectionMapper MapSection) {
 
  // Map the rest of the sections.
  mapAllocatableSections(MapSection);
+
+ if (StartBD) {
+ const uint64_t ReservedSpace = EndBD->getAddress() - StartBD->getAddress();
+ const uint64_t AllocatedSize = NextAvailableAddress - StartBD->getAddress();
+ if (ReservedSpace < AllocatedSize) {
+ BC->errs() << "BOLT-ERROR: reserved space (" << ReservedSpace << " byte"
+ << (ReservedSpace == 1 ? "" : "s")
+ << ") is smaller than required for new allocations ("
+ << AllocatedSize << " bytes)\n";
+ exit(1);
+ }
+ }
 }
 
 std::vector<BinarySection *> RewriteInstance::getCodeSections() {
@@ -3854,7 +3891,7 @@ void RewriteInstance::mapCodeSections(BOLTLinker::SectionMapper MapSection) {
  // Add the new text section aggregating all existing code sections.
  // This is pseudo-section that serves a purpose of creating a corresponding
  // entry in section header table.
- int64_t NewTextSectionSize =
+ const uint64_t NewTextSectionSize =
  NextAvailableAddress - NewTextSectionStartAddress;
  if (NewTextSectionSize) {
  const unsigned Flags = BinarySection::getFlags(/*IsReadOnly=*/true,
@@ -3937,7 +3974,7 @@ void RewriteInstance::mapAllocatableSections(
  if (PHDRTableAddress) {
  // Segment size includes the size of the PHDR area.
  NewTextSegmentSize = NextAvailableAddress - PHDRTableAddress;
- } else {
+ } else if (NewTextSegmentAddress) {
  // Existing PHDR table would be updated.
  NewTextSegmentSize = NextAvailableAddress - NewTextSegmentAddress;
  }
@@ -3976,7 +4013,7 @@ void RewriteInstance::patchELFPHDRTable() {
  assert(!PHDRTableAddress && "unexpected address for program header table");
  PHDRTableOffset = Obj.getHeader().e_phoff;
  if (NewWritableSegmentSize) {
- BC->errs() << "Unable to add writable segment with UseGnuStack option\n";
+ BC->errs() << "BOLT-ERROR: unable to add writable segment\n";
  exit(1);
  }
  }
@@ -3986,7 +4023,7 @@ void RewriteInstance::patchELFPHDRTable() {
  if (!NewWritableSegmentSize) {
  if (PHDRTableAddress)
  NewTextSegmentSize = NextAvailableAddress - PHDRTableAddress;
- else
+ else if (NewTextSegmentAddress)
  NewTextSegmentSize = NextAvailableAddress - NewTextSegmentAddress;
  } else {
  NewWritableSegmentSize = NextAvailableAddress - NewWritableSegmentAddress;
@@ -4020,8 +4057,10 @@ void RewriteInstance::patchELFPHDRTable() {
  };
 
  auto writeNewSegmentPhdrs = [&]() {
- ELF64LE::Phdr NewTextPhdr = createNewTextPhdr();
- OS.write(reinterpret_cast<const char *>(&NewTextPhdr), sizeof(NewTextPhdr));
+ if (PHDRTableAddress || NewTextSegmentSize) {
+ ELF64LE::Phdr NewPhdr = createNewTextPhdr();
+ OS.write(reinterpret_cast<const char *>(&NewPhdr), sizeof(NewPhdr));
+ }
 
  if (NewWritableSegmentSize) {
  ELF64LEPhdrTy NewPhdr;
@@ -4119,9 +4158,8 @@ void RewriteInstance::rewriteNoteSections() {
  const ELFFile<ELF64LE> &Obj = ELF64LEFile->getELFFile();
  raw_fd_ostream &OS = Out->os();
 
- uint64_t NextAvailableOffset = getFileOffsetForAddress(NextAvailableAddress);
- assert(NextAvailableOffset >= FirstNonAllocatableOffset &&
- "next available offset calculation failure");
+ uint64_t NextAvailableOffset = std::max(
+ getFileOffsetForAddress(NextAvailableAddress), FirstNonAllocatableOffset);
  OS.seek(NextAvailableOffset);
 
  // Copy over non-allocatable section contents and update file offsets.
@@ -4860,7 +4898,7 @@ void RewriteInstance::updateELFSymbolTable(
  ++NumHotDataSymsUpdated;
  }
 
- if (*SymbolName == "_end")
+ if (*SymbolName == "_end" && NextAvailableAddress > Symbol.st_value)
  updateSymbolValue(*SymbolName, NextAvailableAddress);
 
  if (IsDynSym)
@@ -4974,13 +5012,6 @@ void RewriteInstance::patchELFSymTabs(ELFObjectFile<ELFT> *File) {
  std::vector<uint32_t> NewSectionIndex;
  getOutputSections(File, NewSectionIndex);
 
- // Set pointer at the end of the output file, so we can pwrite old symbol
- // tables if we need to.
- uint64_t NextAvailableOffset = getFileOffsetForAddress(NextAvailableAddress);
- assert(NextAvailableOffset >= FirstNonAllocatableOffset &&
- "next available offset calculation failure");
- Out->os().seek(NextAvailableOffset);
-
  // Update dynamic symbol table.
  const ELFShdrTy *DynSymSection = nullptr;
  for (const ELFShdrTy &Section : cantFail(Obj.sections())) {
@@ -4992,6 +5023,10 @@ void RewriteInstance::patchELFSymTabs(ELFObjectFile<ELFT> *File) {
  assert((DynSymSection || BC->IsStaticExecutable) &&
  "dynamic symbol table expected");
  if (DynSymSection) {
+ // Set pointer to the end of the section, so we can use pwrite to update
+ // the dynamic symbol table.
+ Out->os().seek(DynSymSection->sh_offset + DynSymSection->sh_size);
+
  updateELFSymbolTable(
  File,
  /*IsDynSym=*/true,
@@ -5545,10 +5580,10 @@ void RewriteInstance::rewriteFile() {
  auto Streamer = BC->createStreamer(OS);
  // Make sure output stream has enough reserved space, otherwise
  // pwrite() will fail.
- uint64_t Offset = OS.seek(getFileOffsetForAddress(NextAvailableAddress));
- (void)Offset;
- assert(Offset == getFileOffsetForAddress(NextAvailableAddress) &&
-  "error resizing output file");
+ uint64_t Offset = std::max(getFileOffsetForAddress(NextAvailableAddress),
+  FirstNonAllocatableOffset);
+ Offset = OS.seek(Offset);
+ assert((Offset != (uint64_t)-1) && "Error resizing output file");
 
  // Overwrite functions with fixed output address. This is mostly used by
  // non-relocation mode, with one exception: injected functions are covered
@@ -5780,7 +5815,7 @@ void RewriteInstance::writeEHFrameHeader() {
  std::vector<char> NewEHFrameHdr = CFIRdWrt->generateEHFrameHeader(
  RelocatedEHFrame, NewEHFrame, EHFrameHdrOutputAddress, FailedAddresses);
 
- assert(Out->os().tell() == EHFrameHdrFileOffset && "offset mismatch");
+ Out->os().seek(EHFrameHdrFileOffset);
  Out->os().write(NewEHFrameHdr.data(), NewEHFrameHdr.size());
 
  const unsigned Flags = BinarySection::getFlags(/*IsReadOnly=*/true,
@@ -5800,6 +5835,15 @@ void RewriteInstance::writeEHFrameHeader() {
 
  NextAvailableAddress += EHFrameHdrSec.getOutputSize();
 
+ if (const BinaryData *ReservedEnd =
+ BC->getBinaryDataByName(getBOLTReservedEnd())) {
+ if (NextAvailableAddress > ReservedEnd->getAddress()) {
+ BC->errs() << "BOLT-ERROR: unable to fit " << getEHFrameHdrSectionName()
+ << " into reserved space\n";
+ exit(1);
+ }
+ }
+
  // Merge new .eh_frame with the relocated original so that gdb can locate all
  // FDEs.
  if (RelocatedEHFrameSection) {

clang/docs/ReleaseNotes.rst

@@ -63,6 +63,12 @@ ABI Changes in This Version
  MSVC uses a different mangling for these objects, compatibility is not affected.
  (#GH85423).
 
+- Fixed Microsoft calling convention for returning certain classes with a
+ templated constructor. If a class has a templated constructor, it should
+ be returned indirectly even if it meets all the other requirements for
+ returning a class in a register. This affects some uses of std::pair.
+ (#GH86384).
+
 AST Dumping Potentially Breaking Changes
 ----------------------------------------
 
@@ -722,6 +728,11 @@ AIX Support
 WebAssembly Support
 ^^^^^^^^^^^^^^^^^^^
 
+The -mcpu=generic configuration now enables multivalue and reference-types.These
+proposals are standardized and available in all major engines. Enabling
+multivalue here only enables the language feature but does not turn on the
+multivalue ABI (this enables non-ABI uses of multivalue, like exnref).
+
 AVR Support
 ^^^^^^^^^^^
 

clang/docs/UsersManual.rst

@@ -1452,8 +1452,6 @@ floating point semantic models: precise (the default), strict, and fast.
  "fenv_access", "off", "on", "off"
  "rounding_mode", "tonearest", "dynamic", "tonearest"
  "contract", "on", "off", "fast"
- "denormal_fp_math", "IEEE", "IEEE", "IEEE"
- "denormal_fp32_math", "IEEE","IEEE", "IEEE"
  "support_math_errno", "on", "on", "off"
  "no_honor_nans", "off", "off", "on"
  "no_honor_infinities", "off", "off", "on"
@@ -1462,6 +1460,14 @@ floating point semantic models: precise (the default), strict, and fast.
  "allow_approximate_fns", "off", "off", "on"
  "allow_reassociation", "off", "off", "on"
 
+The ``-ffp-model`` option does not modify the ``fdenormal-fp-math``
+setting, but it does have an impact on whether ``crtfastmath.o`` is
+linked. Because linking ``crtfastmath.o`` has a global effect on the
+program, and because the global denormal handling can be changed in
+other ways, the state of ``fdenormal-fp-math`` handling cannot
+be assumed in any function based on fp-model. See :ref:`crtfastmath.o`
+for more details.
+
 .. option:: -ffast-math
 
  Enable fast-math mode. This option lets the
@@ -1537,7 +1543,6 @@ floating point semantic models: precise (the default), strict, and fast.
  Also, this option resets following options to their target-dependent defaults.
 
  * ``-f[no-]math-errno``
- * ``-fdenormal-fp-math=<value>``
 
  There is ambiguity about how ``-ffp-contract``, ``-ffast-math``,
  and ``-fno-fast-math`` behave when combined. To keep the value of
@@ -1560,8 +1565,7 @@ floating point semantic models: precise (the default), strict, and fast.
  ``-ffp-contract`` setting is determined by the default value of
  ``-ffp-contract``.
 
- Note: ``-fno-fast-math`` implies ``-fdenormal-fp-math=ieee``.
- ``-fno-fast-math`` causes ``crtfastmath.o`` to not be linked with code
+ Note: ``-fno-fast-math`` causes ``crtfastmath.o`` to not be linked with code
  unless ``-mdaz-ftz`` is present.
 
 .. option:: -fdenormal-fp-math=<value>
@@ -1694,7 +1698,6 @@ floating point semantic models: precise (the default), strict, and fast.
  * ``-fsigned-zeros``
  * ``-ftrapping-math``
  * ``-ffp-contract=on``
- * ``-fdenormal-fp-math=ieee``
 
  There is ambiguity about how ``-ffp-contract``,
  ``-funsafe-math-optimizations``, and ``-fno-unsafe-math-optimizations``

clang/include/clang/AST/NestedNameSpecifier.h

@@ -266,7 +266,7 @@ class NestedNameSpecifierLoc {
  explicit operator bool() const { return Qualifier; }
 
  /// Evaluates true when this nested-name-specifier location is
- /// empty.
+ /// non-empty.
  bool hasQualifier() const { return Qualifier; }
 
  /// Retrieve the nested-name-specifier to which this instance

clang/include/clang/Driver/Options.td

@@ -2888,6 +2888,17 @@ def flax_vector_conversions : Flag<["-"], "flax-vector-conversions">, Group<f_Gr
 def flimited_precision_EQ : Joined<["-"], "flimited-precision=">, Group<f_Group>;
 def fapple_link_rtlib : Flag<["-"], "fapple-link-rtlib">, Group<f_Group>,
  HelpText<"Force linking the clang builtins runtime library">;
+
+/// ClangIR-specific options - BEGIN
+defm clangir : BoolFOption<"clangir",
+ FrontendOpts<"UseClangIRPipeline">, DefaultFalse,
+ PosFlag<SetTrue, [], [ClangOption, CC1Option], "Use the ClangIR pipeline to compile">,
+ NegFlag<SetFalse, [], [ClangOption, CC1Option], "Use the AST -> LLVM pipeline to compile">,
+ BothFlags<[], [ClangOption, CC1Option], "">>;
+def emit_cir : Flag<["-"], "emit-cir">, Visibility<[CC1Option]>,
+ Group<Action_Group>, HelpText<"Build ASTs and then lower to ClangIR">;
+/// ClangIR-specific options - END
+
 def flto_EQ : Joined<["-"], "flto=">,
  Visibility<[ClangOption, CLOption, CC1Option, FC1Option, FlangOption]>,
  Group<f_Group>,

clang/include/clang/Frontend/FrontendOptions.h

@@ -65,6 +65,9 @@ enum ActionKind {
  /// Translate input source into HTML.
  EmitHTML,
 
+ /// Emit a .cir file
+ EmitCIR,
+
  /// Emit a .ll file.
  EmitLLVM,
 
@@ -408,6 +411,10 @@ class FrontendOptions {
  LLVM_PREFERRED_TYPE(bool)
  unsigned GenReducedBMI : 1;
 
+ /// Use Clang IR pipeline to emit code
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned UseClangIRPipeline : 1;
+
  CodeCompleteOptions CodeCompleteOpts;
 
  /// Specifies the output format of the AST.
@@ -590,7 +597,7 @@ class FrontendOptions {
  EmitSymbolGraph(false), EmitExtensionSymbolGraphs(false),
  EmitSymbolGraphSymbolLabelsForTesting(false),
  EmitPrettySymbolGraphs(false), GenReducedBMI(false),
- TimeTraceGranularity(500) {}
+ UseClangIRPipeline(false), TimeTraceGranularity(500) {}
 
  /// getInputKindForExtension - Return the appropriate input kind for a file
  /// extension. For example, "c" would return Language::C.

clang/include/clang/Sema/DeclSpec.h

@@ -1811,15 +1811,15 @@ class DecompositionDeclarator {
  : Bindings(nullptr), NumBindings(0), DeleteBindings(false) {}
  DecompositionDeclarator(const DecompositionDeclarator &G) = delete;
  DecompositionDeclarator &operator=(const DecompositionDeclarator &G) = delete;
- ~DecompositionDeclarator() {
- if (DeleteBindings)
- delete[] Bindings;
- }
+ ~DecompositionDeclarator() { clear(); }
 
  void clear() {
  LSquareLoc = RSquareLoc = SourceLocation();
  if (DeleteBindings)
  delete[] Bindings;
+ else
+ llvm::for_each(llvm::MutableArrayRef(Bindings, NumBindings),
+ [](Binding &B) { B.Attrs.reset(); });
  Bindings = nullptr;
  NumBindings = 0;
  DeleteBindings = false;

clang/lib/AST/DeclBase.cpp

@@ -1115,7 +1115,7 @@ int64_t Decl::getID() const {
 
 const FunctionType *Decl::getFunctionType(bool BlocksToo) const {
  QualType Ty;
- if (const auto *D = dyn_cast<BindingDecl>(this))
+ if (isa<BindingDecl>(this))
  return nullptr;
  else if (const auto *D = dyn_cast<ValueDecl>(this))
  Ty = D->getType();

clang/lib/Basic/Targets/WebAssembly.cpp

@@ -148,20 +148,26 @@ void WebAssemblyTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
 bool WebAssemblyTargetInfo::initFeatureMap(
  llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
  const std::vector<std::string> &FeaturesVec) const {
- if (CPU == "bleeding-edge") {
+ auto addGenericFeatures = [&]() {
+ Features["multivalue"] = true;
+ Features["mutable-globals"] = true;
+ Features["reference-types"] = true;
+ Features["sign-ext"] = true;
+ };
+ auto addBleedingEdgeFeatures = [&]() {
+ addGenericFeatures();
  Features["atomics"] = true;
  Features["bulk-memory"] = true;
  Features["multimemory"] = true;
- Features["mutable-globals"] = true;
  Features["nontrapping-fptoint"] = true;
- Features["reference-types"] = true;
- Features["sign-ext"] = true;
  Features["tail-call"] = true;
  Features["half-precision"] = true;
  setSIMDLevel(Features, SIMD128, true);
- } else if (CPU == "generic") {
- Features["mutable-globals"] = true;
- Features["sign-ext"] = true;
+ };
+ if (CPU == "generic") {
+ addGenericFeatures();
+ } else if (CPU == "bleeding-edge") {
+ addBleedingEdgeFeatures();
  }
 
  return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);