Fetch Upstream

bolt/include/bolt/Core/BinaryDomTree.h

@@ -0,0 +1,57 @@
+//==- bolt/Core/BinaryDomTree.h - Dominator Tree at low-level IR -*- C++ -*-==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the BinaryDomTree class, which represents a dominator tree
+// in the CFG of a binary function.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef BOLT_CORE_BINARY_DOMTREE_H
+#define BOLT_CORE_BINARY_DOMTREE_H
+
+#include "llvm/Support/GenericDomTreeConstruction.h"
+
+namespace llvm {
+namespace bolt {
+
+class BinaryBasicBlock;
+using BinaryDomTreeNode = DomTreeNodeBase<BinaryBasicBlock>;
+using BinaryDominatorTree = DomTreeBase<BinaryBasicBlock>;
+
+} // namespace bolt
+
+// BinaryDominatorTree GraphTraits specializations.
+template <>
+struct GraphTraits<bolt::BinaryDomTreeNode *>
+    : public DomTreeGraphTraitsBase<bolt::BinaryDomTreeNode,
+                                    bolt::BinaryDomTreeNode::iterator> {};
+
+template <>
+struct GraphTraits<const bolt::BinaryDomTreeNode *>
+    : public DomTreeGraphTraitsBase<const bolt::BinaryDomTreeNode,
+                                    bolt::BinaryDomTreeNode::const_iterator> {};
+
+template <>
+struct GraphTraits<bolt::BinaryDominatorTree *>
+    : public GraphTraits<bolt::BinaryDomTreeNode *> {
+  static NodeRef getEntryNode(bolt::BinaryDominatorTree *DT) {
+    return DT->getRootNode();
+  }
+
+  static nodes_iterator nodes_begin(bolt::BinaryDominatorTree *N) {
+    return df_begin(getEntryNode(N));
+  }
+
+  static nodes_iterator nodes_end(bolt::BinaryDominatorTree *N) {
+    return df_end(getEntryNode(N));
+  }
+};
+
+} // namespace llvm
+
+#endif

bolt/include/bolt/Core/BinaryLoop.h

@@ -15,18 +15,13 @@
 #ifndef BOLT_CORE_BINARY_LOOP_H
 #define BOLT_CORE_BINARY_LOOP_H
 
-#include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/Analysis/LoopInfoImpl.h"
-#include "llvm/Support/GenericDomTreeConstruction.h"
 
 namespace llvm {
 namespace bolt {
 
 class BinaryBasicBlock;
 
-using BinaryDomTreeNode = DomTreeNodeBase<BinaryBasicBlock>;
-using BinaryDominatorTree = DomTreeBase<BinaryBasicBlock>;
-
 class BinaryLoop : public LoopBase<BinaryBasicBlock, BinaryLoop> {
 public:
   BinaryLoop() : LoopBase<BinaryBasicBlock, BinaryLoop>() {}
@@ -62,35 +57,4 @@ class BinaryLoopInfo : public LoopInfoBase<BinaryBasicBlock, BinaryLoop> {
 } // namespace bolt
 } // namespace llvm
 
-namespace llvm {
-
-// BinaryDominatorTree GraphTraits specializations.
-template <>
-struct GraphTraits<bolt::BinaryDomTreeNode *>
-    : public DomTreeGraphTraitsBase<bolt::BinaryDomTreeNode,
-                                    bolt::BinaryDomTreeNode::iterator> {};
-
-template <>
-struct GraphTraits<const bolt::BinaryDomTreeNode *>
-    : public DomTreeGraphTraitsBase<const bolt::BinaryDomTreeNode,
-                                    bolt::BinaryDomTreeNode::const_iterator> {};
-
-template <>
-struct GraphTraits<bolt::BinaryDominatorTree *>
-    : public GraphTraits<bolt::BinaryDomTreeNode *> {
-  static NodeRef getEntryNode(bolt::BinaryDominatorTree *DT) {
-    return DT->getRootNode();
-  }
-
-  static nodes_iterator nodes_begin(bolt::BinaryDominatorTree *N) {
-    return df_begin(getEntryNode(N));
-  }
-
-  static nodes_iterator nodes_end(bolt::BinaryDominatorTree *N) {
-    return df_end(getEntryNode(N));
-  }
-};
-
-} // namespace llvm
-
 #endif

bolt/lib/Core/BinaryBasicBlock.cpp

@@ -328,6 +328,7 @@ void BinaryBasicBlock::removePredecessor(BinaryBasicBlock *Pred,
     }
   }
   assert(Erased && "Pred is not a predecessor of this block!");
+  (void)Erased;
 }
 
 void BinaryBasicBlock::removeDuplicateConditionalSuccessor(MCInst *CondBranch) {

bolt/lib/Core/BinaryContext.cpp

@@ -809,6 +809,7 @@ BinaryContext::duplicateJumpTable(BinaryFunction &Function, JumpTable *JT,
     break;
   }
   assert(Found && "Label not found");
+  (void)Found;
   MCSymbol *NewLabel = Ctx->createNamedTempSymbol("duplicatedJT");
   JumpTable *NewJT =
       new JumpTable(*NewLabel, JT->getAddress(), JT->EntrySize, JT->Type,
@@ -1172,6 +1173,7 @@ void BinaryContext::postProcessSymbolTable() {
     }
   }
   assert(Valid);
+  (void)Valid;
   generateSymbolHashes();
 }
 

bolt/lib/Core/BinaryFunction.cpp

@@ -12,6 +12,7 @@
 
 #include "bolt/Core/BinaryFunction.h"
 #include "bolt/Core/BinaryBasicBlock.h"
+#include "bolt/Core/BinaryDomTree.h"
 #include "bolt/Core/DynoStats.h"
 #include "bolt/Core/MCPlusBuilder.h"
 #include "bolt/Utils/NameResolver.h"

bolt/lib/Rewrite/RewriteInstance.cpp

@@ -4048,6 +4048,7 @@ void RewriteInstance::rewriteNoteSections() {
 
       if (BSec->getAllocAddress()) {
         assert(!DataWritten && "Writing section twice.");
+        (void)DataWritten;
         SectionData = BSec->getOutputData();
 
         LLVM_DEBUG(dbgs() << "BOLT-DEBUG: " << (Size ? "appending" : "writing")

bolt/test/X86/gotpcrelx.s

@@ -0,0 +1,54 @@
+# This reproduces a bug with misinterpreting the gotpcrelx reloc
+
+# Here we use llvm-mc -relax-relocations to produce R_X86_64_REX_GOTPCRELX
+# and ld.lld to consume it and optimize it, transforming a CMP <mem, reg>
+# into CMP <imm, reg>.
+# Then we check that BOLT updates correctly the imm operand that references
+# a function address. Currently XFAIL as we do not support it.
+
+# REQUIRES: system-linux
+# XFAIL: *
+
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-linux \
+# RUN:   -relax-relocations %s -o %t.o
+# RUN: llvm-strip --strip-unneeded %t.o
+# RUN: ld.lld %t.o -o %t.exe -q
+# RUN: llvm-readobj -r %t.exe | FileCheck --check-prefix=READOBJ %s
+# RUN: llvm-bolt %t.exe -relocs -o %t.out -lite=0
+# RUN: llvm-objdump -d --no-show-raw-insn --print-imm-hex \
+# RUN:   %t.out | FileCheck --check-prefix=DISASM %s
+
+# Check that R_X86_64_REX_GOTPCRELX is present in the input binary
+# READOBJ: 0x[[#%X,]] R_X86_64_REX_GOTPCRELX foo 0x[[#%X,]]
+
+# DISASM:      Disassembly of section .text:
+# DISASM-EMPTY:
+# DISASM-NEXT: <_start>:
+# DISASM-NEXT:                 leaq  0x[[#%x,ADDR:]], %rax
+# DISASM-NEXT:                 cmpq  0x[[#ADDR]], %rax
+
+  .text
+  .globl _start
+  .type _start, %function
+_start:
+  .cfi_startproc
+  leaq foo, %rax
+  cmpq foo@GOTPCREL(%rip), %rax
+  je  b
+c:
+  mov $1, %rdi
+  callq foo
+b:
+  xorq %rdi, %rdi
+  callq foo
+  ret
+  .cfi_endproc
+  .size _start, .-_start
+
+  .globl foo
+  .type foo, %function
+foo:
+  .cfi_startproc
+  ret
+  .cfi_endproc
+  .size foo, .-foo

clang-tools-extra/clang-tidy/readability/ContainerContainsCheck.cpp

@@ -108,10 +108,8 @@ void ContainerContainsCheck::check(const MatchFinder::MatchResult &Result) {
       Result.Nodes.getNodeAs<Expr>("positiveComparison");
   const auto *NegativeComparison =
       Result.Nodes.getNodeAs<Expr>("negativeComparison");
-  assert(
-      !PositiveComparison ||
-      !NegativeComparison &&
-          "only one of PositiveComparison or NegativeComparison should be set");
+  assert((!PositiveComparison || !NegativeComparison) &&
+         "only one of PositiveComparison or NegativeComparison should be set");
   bool Negated = NegativeComparison != nullptr;
   const auto *Comparison = Negated ? NegativeComparison : PositiveComparison;
 

clang-tools-extra/clang-tidy/readability/SimplifyBooleanExprCheck.cpp

@@ -236,41 +236,6 @@ static std::string replacementExpression(const ASTContext &Context,
   return asBool(getText(Context, *E), NeedsStaticCast);
 }
 
-static const Expr *stmtReturnsBool(const ReturnStmt *Ret, bool Negated) {
-  if (const auto *Bool = dyn_cast<CXXBoolLiteralExpr>(Ret->getRetValue())) {
-    if (Bool->getValue() == !Negated)
-      return Bool;
-  }
-  if (const auto *Unary = dyn_cast<UnaryOperator>(Ret->getRetValue())) {
-    if (Unary->getOpcode() == UO_LNot) {
-      if (const auto *Bool =
-              dyn_cast<CXXBoolLiteralExpr>(Unary->getSubExpr())) {
-        if (Bool->getValue() == Negated)
-          return Bool;
-      }
-    }
-  }
-
-  return nullptr;
-}
-
-static const Expr *stmtReturnsBool(const IfStmt *IfRet, bool Negated) {
-  if (IfRet->getElse() != nullptr)
-    return nullptr;
-
-  if (const auto *Ret = dyn_cast<ReturnStmt>(IfRet->getThen()))
-    return stmtReturnsBool(Ret, Negated);
-
-  if (const auto *Compound = dyn_cast<CompoundStmt>(IfRet->getThen())) {
-    if (Compound->size() == 1) {
-      if (const auto *CompoundRet = dyn_cast<ReturnStmt>(Compound->body_back()))
-        return stmtReturnsBool(CompoundRet, Negated);
-    }
-  }
-
-  return nullptr;
-}
-
 static bool containsDiscardedTokens(const ASTContext &Context,
                                     CharSourceRange CharRange) {
   std::string ReplacementText =
@@ -386,6 +351,9 @@ class SimplifyBooleanExprCheck::Visitor : public RecursiveASTVisitor<Visitor> {
   }
 
   bool VisitIfStmt(IfStmt *If) {
+    // Skip any if's that have a condition var or an init statement.
+    if (If->hasInitStorage() || If->hasVarStorage())
+      return true;
     /*
      * if (true) ThenStmt(); -> ThenStmt();
      * if (false) ThenStmt(); -> <Empty>;
@@ -496,14 +464,17 @@ class SimplifyBooleanExprCheck::Visitor : public RecursiveASTVisitor<Visitor> {
          * if (Cond) return false; return true; -> return !Cond;
          */
         auto *If = cast<IfStmt>(*First);
-        ExprAndBool ThenReturnBool =
-            checkSingleStatement(If->getThen(), parseReturnLiteralBool);
-        if (ThenReturnBool && ThenReturnBool.Bool != TrailingReturnBool.Bool) {
-          if (Check->ChainedConditionalReturn ||
-              (!PrevIf && If->getElse() == nullptr)) {
-            Check->replaceCompoundReturnWithCondition(
-                Context, cast<ReturnStmt>(*Second), TrailingReturnBool.Bool,
-                If);
+        if (!If->hasInitStorage() && !If->hasVarStorage()) {
+          ExprAndBool ThenReturnBool =
+              checkSingleStatement(If->getThen(), parseReturnLiteralBool);
+          if (ThenReturnBool &&
+              ThenReturnBool.Bool != TrailingReturnBool.Bool) {
+            if (Check->ChainedConditionalReturn ||
+                (!PrevIf && If->getElse() == nullptr)) {
+              Check->replaceCompoundReturnWithCondition(
+                  Context, cast<ReturnStmt>(*Second), TrailingReturnBool.Bool,
+                  If, ThenReturnBool.Item);
+            }
           }
         }
       } else if (isa<LabelStmt, CaseStmt, DefaultStmt>(*First)) {
@@ -516,14 +487,15 @@ class SimplifyBooleanExprCheck::Visitor : public RecursiveASTVisitor<Visitor> {
             : isa<CaseStmt>(*First) ? cast<CaseStmt>(*First)->getSubStmt()
                                     : cast<DefaultStmt>(*First)->getSubStmt();
         auto *SubIf = dyn_cast<IfStmt>(SubStmt);
-        if (SubIf && !SubIf->getElse()) {
+        if (SubIf && !SubIf->getElse() && !SubIf->hasInitStorage() &&
+            !SubIf->hasVarStorage()) {
           ExprAndBool ThenReturnBool =
               checkSingleStatement(SubIf->getThen(), parseReturnLiteralBool);
           if (ThenReturnBool &&
               ThenReturnBool.Bool != TrailingReturnBool.Bool) {
             Check->replaceCompoundReturnWithCondition(
                 Context, cast<ReturnStmt>(*Second), TrailingReturnBool.Bool,
-                SubIf);
+                SubIf, ThenReturnBool.Item);
           }
         }
       }
@@ -689,11 +661,11 @@ void SimplifyBooleanExprCheck::replaceWithReturnCondition(
 
 void SimplifyBooleanExprCheck::replaceCompoundReturnWithCondition(
     const ASTContext &Context, const ReturnStmt *Ret, bool Negated,
-    const IfStmt *If) {
-  const auto *Lit = stmtReturnsBool(If, Negated);
+    const IfStmt *If, const Expr *ThenReturn) {
   const std::string Replacement =
       "return " + replacementExpression(Context, Negated, If->getCond());
-  issueDiag(Context, Lit->getBeginLoc(), SimplifyConditionalReturnDiagnostic,
+  issueDiag(Context, ThenReturn->getBeginLoc(),
+            SimplifyConditionalReturnDiagnostic,
             SourceRange(If->getBeginLoc(), Ret->getEndLoc()), Replacement);
 }
 

clang-tools-extra/clang-tidy/readability/SimplifyBooleanExprCheck.h

@@ -55,7 +55,8 @@ class SimplifyBooleanExprCheck : public ClangTidyCheck {
 
   void replaceCompoundReturnWithCondition(const ASTContext &Context,
                                           const ReturnStmt *Ret, bool Negated,
-                                          const IfStmt *If);
+                                          const IfStmt *If,
+                                          const Expr *ThenReturn);
 
   void issueDiag(const ASTContext &Result, SourceLocation Loc,
                  StringRef Description, SourceRange ReplacementRange,

clang-tools-extra/clangd/CMakeLists.txt

@@ -119,6 +119,7 @@ add_clang_library(clangDaemon
   index/Ref.cpp
   index/Relation.cpp
   index/Serialization.cpp
+  index/StdLib.cpp
   index/Symbol.cpp
   index/SymbolCollector.cpp
   index/SymbolID.cpp