Merge pull request #168 from sx-aurora-dev/merge/develop-upstream-20220316

Merge/develop upstream 20220316

Author: kaz7

.github/workflows/issue-release-workflow.yml

@@ -19,9 +19,12 @@ on:
     types:
       - created
       - edited
+  issues:
+    types:
+      - opened
 
 env:
-  COMMENT_BODY: ${{ github.event.comment.body }}
+  COMMENT_BODY: ${{ github.event.action == 'opened' && github.event.issue.body || github.event.comment.body  }}
 
 jobs:
   backport-commits:
@@ -30,7 +33,7 @@ jobs:
     if: >-
         (github.repository == 'llvm/llvm-project') &&
         !startswith(github.event.comment.body, '<!--IGNORE-->') &&
-        contains(github.event.comment.body, '/cherry-pick')
+        contains(github.event.action == 'opened' && github.event.issue.body || github.event.comment.body, '/cherry-pick')
     steps:
       - name: Fetch LLVM sources
         uses: actions/checkout@v2

.github/workflows/issue-subscriber.yml

@@ -18,9 +18,12 @@ jobs:
         pip install -r requirements.txt
 
     - name: Update watchers
+      # https://docs.github.com/en/actions/security-guides/security-hardening-for-github-actions#using-an-intermediate-environment-variable
+      env:
+        LABEL_NAME: ${{ github.event.label.name }}
       run: |
         ./github-automation.py \
-          --token ${{ secrets.ISSUE_SUBSCRIBER_TOKEN }} \
+          --token '${{ secrets.ISSUE_SUBSCRIBER_TOKEN }}' \
           issue-subscriber \
-          --issue-number ${{ github.event.issue.number }} \
-          --label-name ${{ github.event.label.name }}
+          --issue-number '${{ github.event.issue.number }}' \
+          --label-name "$LABEL_NAME"

.github/workflows/llvm-bugs.yml

@@ -48,6 +48,7 @@ jobs:
                 to: "llvm-bugs@lists.llvm.org",
                 subject: `[Bug ${issue.data.number}] ${issue.data.title}`,
                 template: "new-github-issue",
+                'o:tracking-clicks': 'no',
                 'h:X-Mailgun-Variables': JSON.stringify(payload)
               };
 

.mailmap

@@ -16,7 +16,7 @@
 # Combinations of both are possible too, see
 # https://git-scm.com/docs/gitmailmap for format details.
 #
-# You can commit changes for your own names and  email addresses without review.
+# You can commit changes for your own names and email addresses without review.
 # If you want to add entries for other people, please have them review the
 # addition.
 #

README.md

@@ -102,8 +102,9 @@ This is an example work-flow and configuration to get and build the LLVM source:
 
         * Running a serial build will be **slow**.  To improve speed, try running a
           parallel build.  That's done by default in Ninja; for ``make``, use the option
-          ``-j NNN``, where ``NNN`` is the number of parallel jobs, e.g. the number of
-          CPUs you have.
+          ``-j NNN``, where ``NNN`` is the number of parallel jobs to run.
+          In most cases, you get the best performance if you specify the number of CPU threads you have.
+          On some Unix systems, you can specify this with ``-j$(nproc)``.
 
       * For more information see [CMake](https://llvm.org/docs/CMake.html)
 

bolt/include/bolt/Core/BinaryContext.h

@@ -211,7 +211,7 @@ class BinaryContext {
   std::map<unsigned, DwarfLineTable> DwarfLineTablesCUMap;
 
 public:
-  static std::unique_ptr<BinaryContext>
+  static Expected<std::unique_ptr<BinaryContext>>
   createBinaryContext(const ObjectFile *File, bool IsPIC,
                       std::unique_ptr<DWARFContext> DwCtx);
 
@@ -489,7 +489,9 @@ class BinaryContext {
   void adjustCodePadding();
 
   /// Regular page size.
-  static constexpr unsigned RegularPageSize = 0x1000;
+  unsigned RegularPageSize{0x1000};
+  static constexpr unsigned RegularPageSizeX86 = 0x1000;
+  static constexpr unsigned RegularPageSizeAArch64 = 0x10000;
 
   /// Huge page size to use.
   static constexpr unsigned HugePageSize = 0x200000;
@@ -1192,14 +1194,14 @@ class BinaryContext {
                                           /*PIC=*/!HasFixedLoadAddress));
     MCEInstance.LocalCtx->setObjectFileInfo(MCEInstance.LocalMOFI.get());
     MCEInstance.MCE.reset(
-        TheTarget->createMCCodeEmitter(*MII, *MRI, *MCEInstance.LocalCtx));
+        TheTarget->createMCCodeEmitter(*MII, *MCEInstance.LocalCtx));
     return MCEInstance;
   }
 
   /// Creating MCStreamer instance.
   std::unique_ptr<MCStreamer>
   createStreamer(llvm::raw_pwrite_stream &OS) const {
-    MCCodeEmitter *MCE = TheTarget->createMCCodeEmitter(*MII, *MRI, *Ctx);
+    MCCodeEmitter *MCE = TheTarget->createMCCodeEmitter(*MII, *Ctx);
     MCAsmBackend *MAB =
         TheTarget->createMCAsmBackend(*STI, *MRI, MCTargetOptions());
     std::unique_ptr<MCObjectWriter> OW = MAB->createObjectWriter(OS);

bolt/include/bolt/Core/BinaryFunction.h

@@ -1299,10 +1299,11 @@ class BinaryFunction {
     case ELF::R_X86_64_32:
     case ELF::R_X86_64_32S:
     case ELF::R_X86_64_64:
+    case ELF::R_X86_64_PC8:
+    case ELF::R_X86_64_PC32:
+    case ELF::R_X86_64_PC64:
       Relocations[Offset] = Relocation{Offset, Symbol, RelType, Addend, Value};
       return;
-    case ELF::R_X86_64_PC32:
-    case ELF::R_X86_64_PC8:
     case ELF::R_X86_64_PLT32:
     case ELF::R_X86_64_GOTPCRELX:
     case ELF::R_X86_64_REX_GOTPCRELX:

bolt/include/bolt/Core/BinarySection.h

@@ -296,6 +296,16 @@ class BinarySection {
     return make_range(Relocations.begin(), Relocations.end());
   }
 
+  /// Iterate over all dynamic relocations for this section.
+  iterator_range<RelocationSetType::iterator> dynamicRelocations() {
+    return make_range(DynamicRelocations.begin(), DynamicRelocations.end());
+  }
+
+  /// Iterate over all dynamic relocations for this section.
+  iterator_range<RelocationSetType::const_iterator> dynamicRelocations() const {
+    return make_range(DynamicRelocations.begin(), DynamicRelocations.end());
+  }
+
   /// Does this section have any non-pending relocations?
   bool hasRelocations() const { return !Relocations.empty(); }
 

bolt/include/bolt/Core/DebugData.h

@@ -490,11 +490,13 @@ class DebugInfoBinaryPatcher : public SimpleBinaryPatcher {
     PatchBaseClass,
     PatchValue32,
     PatchValue64to32,
+    PatchValue32GenericSize,
     PatchValue64,
     PatchValueVariable,
     ReferencePatchValue,
     DWARFUnitOffsetBaseLabel,
-    DestinationReferenceLabel
+    DestinationReferenceLabel,
+    NewDebugEntry
   };
 
   struct Patch {
@@ -535,6 +537,22 @@ class DebugInfoBinaryPatcher : public SimpleBinaryPatcher {
     uint32_t Value;
   };
 
+  /// Patch for 4 byte entry, where original entry size is not 4 bytes or 8
+  /// bytes.
+  struct DebugPatch32GenericSize : public Patch {
+    DebugPatch32GenericSize(uint32_t O, uint32_t V, uint32_t OVS)
+        : Patch(O, DebugPatchKind::PatchValue32GenericSize) {
+      Value = V;
+      OldValueSize = OVS;
+    }
+
+    static bool classof(const Patch *Writer) {
+      return Writer->getKind() == DebugPatchKind::PatchValue32GenericSize;
+    }
+    uint32_t Value;
+    uint32_t OldValueSize;
+  };
+
   struct DebugPatch64 : public Patch {
     DebugPatch64(uint32_t O, uint64_t V)
         : Patch(O, DebugPatchKind::PatchValue64) {
@@ -605,6 +623,22 @@ class DebugInfoBinaryPatcher : public SimpleBinaryPatcher {
     }
   };
 
+  struct NewDebugEntry : public Patch {
+    NewDebugEntry() = delete;
+    NewDebugEntry(uint32_t O, std::string &&V)
+        : Patch(O, DebugPatchKind::NewDebugEntry) {
+      CurrentOrder = NewDebugEntry::OrderCounter++;
+      Value = std::move(V);
+    }
+
+    static bool classof(const Patch *Writer) {
+      return Writer->getKind() == DebugPatchKind::NewDebugEntry;
+    }
+    static uint32_t OrderCounter;
+    uint32_t CurrentOrder;
+    std::string Value;
+  };
+
   virtual PatcherKind getKind() const override {
     return PatcherKind::DebugInfoBinaryPatcher;
   }
@@ -646,6 +680,12 @@ class DebugInfoBinaryPatcher : public SimpleBinaryPatcher {
   void addReferenceToPatch(uint64_t Offset, uint32_t DestinationOffset,
                            uint32_t OldValueSize, dwarf::Form Form);
 
+  /// Inserts a new uint32_t \p Value at the end of \p DIE .
+  void insertNewEntry(const DWARFDie &DIE, uint32_t);
+
+  /// Inserts a new encoded \p Value at the end of \p DIE .
+  void insertNewEntry(const DWARFDie &DIE, std::string &&Value);
+
   /// Clears unordered set for DestinationLabels.
   void clearDestinationLabels() { DestinationLabels.clear(); }
 
@@ -670,6 +710,9 @@ class DebugInfoBinaryPatcher : public SimpleBinaryPatcher {
       case DebugPatchKind::PatchValue64to32:
         delete reinterpret_cast<DebugPatch64to32 *>(P);
         break;
+      case DebugPatchKind::PatchValue32GenericSize:
+        delete reinterpret_cast<DebugPatch32GenericSize *>(P);
+        break;
       case DebugPatchKind::PatchValue64:
         delete reinterpret_cast<DebugPatch64 *>(P);
         break;
@@ -685,6 +728,9 @@ class DebugInfoBinaryPatcher : public SimpleBinaryPatcher {
       case DebugPatchKind::DestinationReferenceLabel:
         delete reinterpret_cast<DestinationReferenceLabel *>(P);
         break;
+      case DebugPatchKind::NewDebugEntry:
+        delete reinterpret_cast<NewDebugEntry *>(P);
+        break;
       }
     }
   };
@@ -728,10 +774,19 @@ class DebugAbbrevWriter {
     uint8_t NewAttrForm;
   };
 
+  struct AbbrevEntry {
+    dwarf::Attribute Attr;
+    dwarf::Form Form;
+  };
+
   using PatchesTy = std::unordered_map<const DWARFAbbreviationDeclaration *,
                                        SmallVector<PatchInfo, 2>>;
   std::unordered_map<const DWARFUnit *, PatchesTy> Patches;
 
+  using AbbrevEntryTy = std::unordered_map<const DWARFAbbreviationDeclaration *,
+                                           SmallVector<AbbrevEntry, 2>>;
+  std::unordered_map<const DWARFUnit *, AbbrevEntryTy> NewAbbrevEntries;
+
   /// DWARF context containing abbreviations.
   DWARFContext &Context;
 
@@ -777,6 +832,27 @@ class DebugAbbrevWriter {
         PatchInfo{AttrTag, NewAttrTag, NewAttrForm});
   }
 
+  /// Adds attribute \p AttrTag and \p NewAttrForm in abbreviation declaration
+  /// \p Abbrev belonging to CU \p Unit .
+  void addAttribute(const DWARFUnit &Unit,
+                    const DWARFAbbreviationDeclaration *Abbrev,
+                    dwarf::Attribute AttrTag, dwarf::Form AttrForm) {
+    assert(&Unit.getContext() == &Context &&
+           "cannot update attribute from a different DWARF context");
+    std::lock_guard<std::mutex> Lock(WriterMutex);
+    bool AlreadyAdded = false;
+    for (AbbrevEntry &E : NewAbbrevEntries[&Unit][Abbrev])
+      if (E.Attr == AttrTag) {
+        AlreadyAdded = true;
+        break;
+      }
+
+    if (AlreadyAdded)
+      return;
+    NewAbbrevEntries[&Unit][Abbrev].emplace_back(
+        AbbrevEntry{AttrTag, AttrForm});
+  }
+
   /// Return a buffer with concatenated abbrev sections for all CUs and TUs
   /// in the associated DWARF context. Section offsets could be queried using
   /// getAbbreviationsOffsetForUnit() interface. For DWP, we are using DWOId
@@ -882,6 +958,17 @@ class DwarfLineTable {
   }
 };
 
+struct AttrInfo {
+  DWARFFormValue V;
+  uint64_t Offset;
+  uint32_t Size; // Size of the attribute.
+};
+
+Optional<AttrInfo>
+findAttributeInfo(const DWARFDie DIE,
+                  const DWARFAbbreviationDeclaration *AbbrevDecl,
+                  uint32_t Index);
+
 } // namespace bolt
 } // namespace llvm
 

bolt/include/bolt/Core/MCPlusBuilder.h

@@ -74,9 +74,9 @@ class MCPlusBuilder {
   AllocatorIdTy MaxAllocatorId = 0;
 
   /// We encode Index and Value into a 64-bit immediate operand value.
-  static int64_t encodeAnnotationImm(unsigned Index, int64_t Value) {
-    assert(Index < 256 && "annotation index max value exceeded");
-    assert((Value == (Value << 8) >> 8) && "annotation value out of range");
+  static int64_t encodeAnnotationImm(uint8_t Index, int64_t Value) {
+    if (LLVM_UNLIKELY(Value != extractAnnotationValue(Value)))
+      report_fatal_error("annotation value out of range");
 
     Value &= 0xff'ffff'ffff'ffff;
     Value |= (int64_t)Index << 56;
@@ -85,14 +85,13 @@ class MCPlusBuilder {
   }
 
   /// Extract annotation index from immediate operand value.
-  static unsigned extractAnnotationIndex(int64_t ImmValue) {
+  static uint8_t extractAnnotationIndex(int64_t ImmValue) {
     return ImmValue >> 56;
   }
 
   /// Extract annotation value from immediate operand value.
   static int64_t extractAnnotationValue(int64_t ImmValue) {
-    ImmValue &= 0xff'ffff'ffff'ffff;
-    return (ImmValue << 8) >> 8;
+    return SignExtend64<56>(ImmValue & 0xff'ffff'ffff'ffffULL);
   }
 
   MCInst *getAnnotationInst(const MCInst &Inst) const {
@@ -425,9 +424,7 @@ class MCPlusBuilder {
 
   /// Return a register number that is guaranteed to not match with
   /// any real register on the underlying architecture.
-  virtual MCPhysReg getNoRegister() const {
-    llvm_unreachable("not implemented");
-  }
+  MCPhysReg getNoRegister() const { return MCRegister::NoRegister; }
 
   /// Return a register corresponding to a function integer argument \p ArgNo
   /// if the argument is passed in a register. Or return the result of
@@ -1295,6 +1292,16 @@ class MCPlusBuilder {
     return false;
   }
 
+  /// Convert a move instruction into a conditional move instruction, given a
+  /// condition code.
+  virtual bool
+  convertMoveToConditionalMove(MCInst &Inst, unsigned CC,
+                               bool AllowStackMemOp = false,
+                               bool AllowBasePtrStackMemOp = false) const {
+    llvm_unreachable("not implemented");
+    return false;
+  }
+
   /// Lower a tail call instruction \p Inst if required by target.
   virtual bool lowerTailCall(MCInst &Inst) {
     llvm_unreachable("not implemented");
@@ -1328,6 +1335,16 @@ class MCPlusBuilder {
     return IndirectBranchType::UNKNOWN;
   }
 
+  /// Analyze branch \p Instruction in PLT section and try to determine
+  /// associated got entry address.
+  virtual uint64_t analyzePLTEntry(MCInst &Instruction,
+                                   InstructionIterator Begin,
+                                   InstructionIterator End,
+                                   uint64_t BeginPC) const {
+    llvm_unreachable("not implemented");
+    return 0;
+  }
+
   virtual bool analyzeVirtualMethodCall(InstructionIterator Begin,
                                         InstructionIterator End,
                                         std::vector<MCInst *> &MethodFetchInsns,