LLVM and SPIRV-LLVM-Translator pulldown (WW26)

LLVM: llvm/llvm-project@daf897d
SPIRV-LLVM-Translator: KhronosGroup/SPIRV-LLVM-Translator@3f5e65d

Author: bb-sycl

.git-blame-ignore-revs

@@ -43,3 +43,6 @@ d8f0e6caa91e230a486c948ab643174e40bdf215
 
 # Use C++11 default member initializers in LLDB. NFC.
 9494c510af56d9c8593ab69017dcaa232210b235
+
+# [libc++][NFC] clang-format <__config>
+ac251726f84d5b7e6533a2e3712920184435b61b

.github/workflows/closed-issues.yml

@@ -10,4 +10,4 @@ jobs:
     steps:
       - uses: andymckay/[email protected]
         with:
-          remove-labels: "awaiting-review"
+          remove-labels: 'awaiting-review'

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

@@ -4,7 +4,7 @@
 # /cherry-pick <commit> <...>
 #
 # This comment will attempt to cherry-pick the given commits to the latest
-# release branch (release/Y.x) and if successful push the result to a branch
+# release branch (release/Y.x) and if successful, push the result to a branch
 # on github.
 #
 # /branch <owner>/<repo>/<branch>
@@ -31,9 +31,9 @@ jobs:
     name: Backport Commits
     runs-on: ubuntu-20.04
     if: >-
-        (github.repository == 'llvm/llvm-project') &&
-        !startswith(github.event.comment.body, '<!--IGNORE-->') &&
-        contains(github.event.action == 'opened' && github.event.issue.body || github.event.comment.body, '/cherry-pick')
+      (github.repository == 'llvm/llvm-project') &&
+      !startswith(github.event.comment.body, '<!--IGNORE-->') &&
+      contains(github.event.action == 'opened' && github.event.issue.body || github.event.comment.body, '/cherry-pick')
     steps:
       - name: Fetch LLVM sources
         uses: actions/checkout@v2
@@ -64,16 +64,16 @@ jobs:
     name: Create Pull Request
     runs-on: ubuntu-20.04
     if: >-
-        (github.repository == 'llvm/llvm-project') &&
-        !startswith(github.event.comment.body, '<!--IGNORE-->') &&
-        contains(github.event.comment.body, '/branch')
+      (github.repository == 'llvm/llvm-project') &&
+      !startswith(github.event.comment.body, '<!--IGNORE-->') &&
+      contains(github.event.comment.body, '/branch')
 
     steps:
       - name: Fetch LLVM sources
         uses: actions/checkout@v2
 
       - name: Setup Environment
-        run:  |
+        run: |
           pip install -r ./llvm/utils/git/requirements.txt
 
       - name: Create Pull Request

.github/workflows/issue-subscriber.yml

@@ -10,20 +10,20 @@ jobs:
     runs-on: ubuntu-latest
     if: github.repository == 'llvm/llvm-project'
     steps:
-    - name: Setup Automation Script
-      run:  |
-        curl -O -L https://raw.githubusercontent.com/$GITHUB_REPOSITORY/$GITHUB_SHA/llvm/utils/git/github-automation.py
-        curl -O -L https://raw.githubusercontent.com/$GITHUB_REPOSITORY/$GITHUB_SHA/llvm/utils/git/requirements.txt
-        chmod a+x github-automation.py
-        pip install -r requirements.txt
+      - name: Setup Automation Script
+        run: |
+          curl -O -L https://raw.githubusercontent.com/$GITHUB_REPOSITORY/$GITHUB_SHA/llvm/utils/git/github-automation.py
+          curl -O -L https://raw.githubusercontent.com/$GITHUB_REPOSITORY/$GITHUB_SHA/llvm/utils/git/requirements.txt
+          chmod a+x github-automation.py
+          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 }}' \
-          issue-subscriber \
-          --issue-number '${{ github.event.issue.number }}' \
-          --label-name "$LABEL_NAME"
+      - 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 }}' \
+            issue-subscriber \
+            --issue-number '${{ github.event.issue.number }}' \
+            --label-name "$LABEL_NAME"

.github/workflows/llvm-bugs.yml

@@ -19,39 +19,39 @@ jobs:
           MAILGUN_API_KEY: ${{ secrets.LLVM_BUGS_KEY }}
         with:
           script: |
-            const Mailgun = require("mailgun.js");
+            const Mailgun = require('mailgun.js');
             const formData = require('form-data');
-            const mailgun = new Mailgun(formData);
 
-            const DOMAIN = "email.llvm.org";
+            const mailgun = new Mailgun(formData);
+            const DOMAIN = 'email.llvm.org';
 
-            const mg = mailgun.client({username: 'api', key: process.env.MAILGUN_API_KEY});
+            const mg = mailgun.client({ username: 'api', key: process.env.MAILGUN_API_KEY });
 
             github.rest.issues.get({
               issue_number: context.issue.number,
               owner: context.repo.owner,
-              repo: context.repo.repo,
+              repo: context.repo.repo
             })
-            .then(function(issue) {
+            .then((issue) => {
               const payload = {
                 author : issue.data.user.login,
                 issue  : issue.data.number,
                 title  : issue.data.title,
                 url    : issue.data.html_url,
-                labels : issue.data.labels.map(label => { return label.name }),
-                assignee : issue.data.assignees.map(assignee => { return assignee.login }),
+                labels : issue.data.labels.map((label) => label.name),
+                assignee : issue.data.assignees.map((assignee) => assignee.login),
                 body   : issue.data.body
               };
-            
+
               const data = {
-                from: "LLVM Bugs <[email protected]>",
-                to: "[email protected]",
+                from: 'LLVM Bugs <[email protected]>',
+                to: '[email protected]',
                 subject: `[Bug ${issue.data.number}] ${issue.data.title}`,
-                template: "new-github-issue",
+                template: 'new-github-issue',
                 'o:tracking-clicks': 'no',
                 'h:X-Mailgun-Variables': JSON.stringify(payload)
               };
 
-              return mg.messages.create(DOMAIN, data)
+              return mg.messages.create(DOMAIN, data);
             })
-            .then(msg => console.log(msg));
+            .then((msg) => console.log(msg));

.github/workflows/new-issues.yml

@@ -10,5 +10,5 @@ jobs:
     steps:
       - uses: andymckay/[email protected]
         with:
-          add-labels: "new issue"
+          add-labels: 'new issue'
           ignore-if-labeled: true

bolt/include/bolt/Core/BinaryBasicBlock.h

@@ -150,11 +150,9 @@ class BinaryBasicBlock {
   BinaryBasicBlock &operator=(const BinaryBasicBlock &) = delete;
   BinaryBasicBlock &operator=(const BinaryBasicBlock &&) = delete;
 
-  explicit BinaryBasicBlock(BinaryFunction *Function, MCSymbol *Label,
-                            uint32_t Offset = INVALID_OFFSET)
+  explicit BinaryBasicBlock(BinaryFunction *Function, MCSymbol *Label)
       : Function(Function), Label(Label) {
     assert(Function && "Function must be non-null");
-    InputRange.first = Offset;
   }
 
   // Exclusively managed by BinaryFunction.
@@ -561,6 +559,12 @@ class BinaryBasicBlock {
   /// Set minimum alignment for the basic block.
   void setAlignment(uint32_t Align) { Alignment = Align; }
 
+  /// Set alignment of the block based on the alignment of its offset.
+  void setDerivedAlignment() {
+    const uint64_t DerivedAlignment = getOffset() & (1 + ~getOffset());
+    Alignment = std::min(DerivedAlignment, uint64_t(32));
+  }
+
   /// Return required alignment for the block.
   uint32_t getAlignment() const { return Alignment; }
 
@@ -787,6 +791,9 @@ class BinaryBasicBlock {
   /// at the split point.
   BinaryBasicBlock *splitAt(iterator II);
 
+  /// Set start offset of this basic block in the input binary.
+  void setOffset(uint32_t Offset) { InputRange.first = Offset; };
+
   /// Sets address of the basic block in the output.
   void setOutputStartAddress(uint64_t Address) {
     OutputAddressRange.first = Address;

bolt/include/bolt/Core/BinaryContext.h

@@ -239,7 +239,7 @@ class BinaryContext {
   Optional<DWARFUnit *> getDWOCU(uint64_t DWOId);
 
   /// Returns DWOContext if it exists.
-  DWARFContext *getDWOContext();
+  DWARFContext *getDWOContext() const;
 
   /// Get Number of DWOCUs in a map.
   uint32_t getNumDWOCUs() { return DWOCUs.size(); }

bolt/include/bolt/Core/BinaryFunction.h

@@ -701,6 +701,28 @@ class BinaryFunction {
     IsInjected = true;
   }
 
+  /// Create a basic block at a given \p Offset in the function and append it
+  /// to the end of list of blocks. Used during CFG construction only.
+  BinaryBasicBlock *addBasicBlockAt(uint64_t Offset, MCSymbol *Label) {
+    assert(CurrentState == State::Disassembled &&
+           "Cannot add block with an offset in non-disassembled state.");
+    assert(!getBasicBlockAtOffset(Offset) &&
+           "Basic block already exists at the offset.");
+
+    BasicBlocks.emplace_back(createBasicBlock(Label).release());
+    BinaryBasicBlock *BB = BasicBlocks.back();
+
+    BB->setIndex(BasicBlocks.size() - 1);
+    BB->setOffset(Offset);
+
+    BasicBlockOffsets.emplace_back(Offset, BB);
+    assert(std::is_sorted(BasicBlockOffsets.begin(), BasicBlockOffsets.end(),
+                          CompareBasicBlockOffsets()) &&
+           std::is_sorted(begin(), end()));
+
+    return BB;
+  }
+
   /// Clear state of the function that could not be disassembled or if its
   /// disassembled state was later invalidated.
   void clearDisasmState();
@@ -842,6 +864,20 @@ class BinaryFunction {
     return (RI == Relocations.end()) ? nullptr : &RI->second;
   }
 
+  /// Return the first relocation in the function that starts at an address in
+  /// the [StartOffset, EndOffset) range. Return nullptr if no such relocation
+  /// exists.
+  const Relocation *getRelocationInRange(uint64_t StartOffset,
+                                         uint64_t EndOffset) const {
+    assert(CurrentState == State::Empty &&
+           "Relocations unavailable in the current function state.");
+    auto RI = Relocations.lower_bound(StartOffset);
+    if (RI != Relocations.end() && RI->first < EndOffset)
+      return &RI->second;
+
+    return nullptr;
+  }
+
   /// Returns the raw binary encoding of this function.
   ErrorOr<ArrayRef<uint8_t>> getData() const;
 
@@ -968,6 +1004,15 @@ class BinaryFunction {
     return const_cast<BinaryFunction *>(this)->getInstructionAtOffset(Offset);
   }
 
+  /// Return offset for the first instruction. If there is data at the
+  /// beginning of a function then offset of the first instruction could
+  /// be different from 0
+  uint64_t getFirstInstructionOffset() const {
+    if (Instructions.empty())
+      return 0;
+    return Instructions.begin()->first;
+  }
+
   /// Return jump table that covers a given \p Address in memory.
   JumpTable *getJumpTableContainingAddress(uint64_t Address) {
     auto JTI = JumpTables.upper_bound(Address);
@@ -1314,11 +1359,11 @@ class BinaryFunction {
     case ELF::R_X86_64_PC8:
     case ELF::R_X86_64_PC32:
     case ELF::R_X86_64_PC64:
+    case ELF::R_X86_64_GOTPCRELX:
+    case ELF::R_X86_64_REX_GOTPCRELX:
       Relocations[Offset] = Relocation{Offset, Symbol, RelType, Addend, Value};
       return;
     case ELF::R_X86_64_PLT32:
-    case ELF::R_X86_64_GOTPCRELX:
-    case ELF::R_X86_64_REX_GOTPCRELX:
     case ELF::R_X86_64_GOTPCREL:
     case ELF::R_X86_64_TPOFF32:
     case ELF::R_X86_64_GOTTPOFF:
@@ -1508,66 +1553,34 @@ class BinaryFunction {
     return Address <= PC && PC < Address + Size;
   }
 
-  /// Create a basic block at a given \p Offset in the
-  /// function.
-  /// If \p DeriveAlignment is true, set the alignment of the block based
-  /// on the alignment of the existing offset.
-  /// The new block is not inserted into the CFG.  The client must
-  /// use insertBasicBlocks to add any new blocks to the CFG.
+  /// Create a basic block in the function. The new block is *NOT* inserted
+  /// into the CFG. The caller must use insertBasicBlocks() to add any new
+  /// blocks to the CFG.
   std::unique_ptr<BinaryBasicBlock>
-  createBasicBlock(uint64_t Offset, MCSymbol *Label = nullptr,
-                   bool DeriveAlignment = false) {
-    assert(BC.Ctx && "cannot be called with empty context");
+  createBasicBlock(MCSymbol *Label = nullptr) {
     if (!Label) {
       std::unique_lock<std::shared_timed_mutex> Lock(BC.CtxMutex);
       Label = BC.Ctx->createNamedTempSymbol("BB");
     }
-    auto BB = std::unique_ptr<BinaryBasicBlock>(
-        new BinaryBasicBlock(this, Label, Offset));
-
-    if (DeriveAlignment) {
-      uint64_t DerivedAlignment = Offset & (1 + ~Offset);
-      BB->setAlignment(std::min(DerivedAlignment, uint64_t(32)));
-    }
+    auto BB =
+        std::unique_ptr<BinaryBasicBlock>(new BinaryBasicBlock(this, Label));
 
     LabelToBB[Label] = BB.get();
 
     return BB;
   }
 
-  /// Create a basic block at a given \p Offset in the
-  /// function and append it to the end of list of blocks.
-  /// If \p DeriveAlignment is true, set the alignment of the block based
-  /// on the alignment of the existing offset.
-  ///
-  /// Returns NULL if basic block already exists at the \p Offset.
-  BinaryBasicBlock *addBasicBlock(uint64_t Offset, MCSymbol *Label = nullptr,
-                                  bool DeriveAlignment = false) {
-    assert((CurrentState == State::CFG || !getBasicBlockAtOffset(Offset)) &&
-           "basic block already exists in pre-CFG state");
-
-    if (!Label) {
-      std::unique_lock<std::shared_timed_mutex> Lock(BC.CtxMutex);
-      Label = BC.Ctx->createNamedTempSymbol("BB");
-    }
-    std::unique_ptr<BinaryBasicBlock> BBPtr =
-        createBasicBlock(Offset, Label, DeriveAlignment);
-    BasicBlocks.emplace_back(BBPtr.release());
+  /// Create a new basic block with an optional \p Label and add it to the list
+  /// of basic blocks of this function.
+  BinaryBasicBlock *addBasicBlock(MCSymbol *Label = nullptr) {
+    assert(CurrentState == State::CFG && "Can only add blocks in CFG state");
 
+    BasicBlocks.emplace_back(createBasicBlock(Label).release());
     BinaryBasicBlock *BB = BasicBlocks.back();
-    BB->setIndex(BasicBlocks.size() - 1);
-
-    if (CurrentState == State::Disassembled) {
-      BasicBlockOffsets.emplace_back(Offset, BB);
-    } else if (CurrentState == State::CFG) {
-      BB->setLayoutIndex(layout_size());
-      BasicBlocksLayout.emplace_back(BB);
-    }
 
-    assert(CurrentState == State::CFG ||
-           (std::is_sorted(BasicBlockOffsets.begin(), BasicBlockOffsets.end(),
-                           CompareBasicBlockOffsets()) &&
-            std::is_sorted(begin(), end())));
+    BB->setIndex(BasicBlocks.size() - 1);
+    BB->setLayoutIndex(layout_size());
+    BasicBlocksLayout.emplace_back(BB);
 
     return BB;
   }

bolt/include/bolt/Core/Relocation.h

@@ -55,7 +55,10 @@ struct Relocation {
   /// Return size of this relocation.
   size_t getSize() const { return getSizeForType(Type); }
 
-  /// Handle special cases when relocation should not be processed by bolt
+  /// Skip relocations that we don't want to handle in BOLT
+  static bool skipRelocationType(uint64_t Type);
+
+  /// Handle special cases when relocation should not be processed by BOLT
   static bool skipRelocationProcess(uint64_t Type, uint64_t Contents);
 
   // Adjust value depending on relocation type (make it PC relative or not)
@@ -77,6 +80,9 @@ struct Relocation {
   /// Return true if relocation type implies the creation of a GOT entry
   static bool isGOT(uint64_t Type);
 
+  /// Special relocation type that allows the linker to modify the instruction.
+  static bool isX86GOTPCRELX(uint64_t Type);
+
   /// Return true if relocation type is NONE
   static bool isNone(uint64_t Type);