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

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

bolt/lib/Passes/ValidateMemRefs.cpp

@@ -29,8 +29,7 @@ bool ValidateMemRefs::checkAndFixJTReference(BinaryFunction &BF, MCInst &Inst,
  if (!BD)
  return false;
 
- const uint64_t TargetAddress = BD->getAddress() + Offset;
- JumpTable *JT = BC.getJumpTableContainingAddress(TargetAddress);
+ JumpTable *JT = BC.getJumpTableContainingAddress(BD->getAddress());
  if (!JT)
  return false;
 
@@ -43,8 +42,9 @@ bool ValidateMemRefs::checkAndFixJTReference(BinaryFunction &BF, MCInst &Inst,
  // the jump table label with a regular rodata reference. Get a
  // non-JT reference by fetching the symbol 1 byte before the JT
  // label.
- MCSymbol *NewSym = BC.getOrCreateGlobalSymbol(TargetAddress - 1, "DATAat");
- BC.MIB->setOperandToSymbolRef(Inst, OperandNum, NewSym, 1, &*BC.Ctx, 0);
+ MCSymbol *NewSym = BC.getOrCreateGlobalSymbol(BD->getAddress() - 1, "DATAat");
+ BC.MIB->setOperandToSymbolRef(Inst, OperandNum, NewSym, Offset + 1, &*BC.Ctx,
+ 0);
  LLVM_DEBUG(dbgs() << "BOLT-DEBUG: replaced reference @" << BF.getPrintName()
  << " from " << BD->getName() << " to " << NewSym->getName()
  << " + 1\n");

bolt/lib/Rewrite/RewriteInstance.cpp

@@ -1513,6 +1513,23 @@ void RewriteInstance::registerFragments() {
  StopSymbol = *FSI;
 
  uint64_t ParentAddress{0};
+
+ // BOLT split fragment symbols are emitted just before the main function
+ // symbol.
+ for (ELFSymbolRef NextSymbol = Symbol; NextSymbol < StopSymbol;
+ NextSymbol.moveNext()) {
+ StringRef Name = cantFail(NextSymbol.getName());
+ if (Name == ParentName) {
+ ParentAddress = cantFail(NextSymbol.getValue());
+ goto registerParent;
+ }
+ if (Name.starts_with(ParentName))
+ // With multi-way splitting, there are multiple fragments with different
+ // suffixes. Parent follows the last fragment.
+ continue;
+ break;
+ }
+
  // Iterate over local file symbols and check symbol names to match parent.
  for (ELFSymbolRef Symbol(FSI[-1]); Symbol < StopSymbol; Symbol.moveNext()) {
  if (cantFail(Symbol.getName()) == ParentName) {
@@ -1521,6 +1538,7 @@ void RewriteInstance::registerFragments() {
  }
  }
 
+registerParent:
  // No local parent is found, use global parent function.
  if (!ParentAddress)
  if (BinaryData *ParentBD = BC->getBinaryDataByName(ParentName))

bolt/test/X86/jt-symbol-disambiguation-4.s

@@ -0,0 +1,60 @@
+# If the operand references a symbol that differs from the jump table label,
+# no reference updating is required even if its target address resides within
+# the jump table's range.
+# In this test case, consider the second instruction within the main function,
+# where the address resulting from 'c + 17' corresponds to one byte beyond the
+# address of the .LJTI2_0 jump table label. However, this operand represents
+# an offset calculation related to the global variable 'c' and should remain
+# unaffected by the jump table.
+
+# REQUIRES: system-linux
+
+
+# RUN: %clang -no-pie %s -o %t.exe -Wl,-q
+
+# RUN: %t.exe
+# RUN: llvm-bolt -funcs=main,foo/1 %t.exe -o %t.exe.bolt -jump-tables=move
+# RUN: %t.exe.bolt
+
+ .text
+ .globl main
+ .type main,@function
+main:
+ pushq %rbp
+ movq %rsp, %rbp
+ movq $-16, %rax
+ movl c+17(%rax), %edx
+ cmpl $255, %edx
+ je .LCorrect
+ movl $1, %eax
+ popq %rbp
+ ret
+.LCorrect:
+ movl $0, %eax
+ popq %rbp
+ ret
+ .p2align 4, 0x90
+ .type foo,@function
+foo:
+ movq $0, %rax
+ jmpq *.LJTI2_0(,%rax,8)
+ addl $-36, %eax
+.LBB2_2:
+ addl $-16, %eax
+ retq
+ .section .rodata,"a",@progbits
+ .type c,@object
+ .data
+ .globl c
+ .p2align 4, 0x0
+c:
+ .byte 1
+ .byte 0xff
+ .zero 14
+ .size c, 16
+.LJTI2_0:
+ .quad .LBB2_2
+ .quad .LBB2_2
+ .quad .LBB2_2
+ .quad .LBB2_2
+

bolt/test/X86/register-fragments-bolt-symbols.s

@@ -0,0 +1,32 @@
+# Test the heuristics for matching BOLT-added split functions.
+
+# RUN: llvm-mc --filetype=obj --triple x86_64-unknown-unknown %S/cdsplit-symbol-names.s -o %t.main.o
+# RUN: llvm-mc --filetype=obj --triple x86_64-unknown-unknown %s -o %t.chain.o
+# RUN: link_fdata %S/cdsplit-symbol-names.s %t.main.o %t.fdata
+# RUN: sed -i 's|chain|chain/2|g' %t.fdata
+# RUN: llvm-strip --strip-unneeded %t.main.o
+# RUN: llvm-objcopy --localize-symbol=chain %t.main.o
+# RUN: %clang %cflags %t.chain.o %t.main.o -o %t.exe -Wl,-q
+# RUN: llvm-bolt %t.exe -o %t.bolt --split-functions --split-strategy=randomN \
+# RUN: --reorder-blocks=ext-tsp --enable-bat --bolt-seed=7 --data=%t.fdata
+# RUN: llvm-objdump --syms %t.bolt | FileCheck %s --check-prefix=CHECK-SYMS
+
+# RUN: link_fdata %s %t.bolt %t.preagg PREAGG
+# PREAGG: B X:0 #chain.cold.0# 1 0
+# RUN: perf2bolt %t.bolt -p %t.preagg --pa -o %t.bat.fdata -w %t.bat.yaml -v=1 \
+# RUN: | FileCheck %s --check-prefix=CHECK-REGISTER
+
+# CHECK-SYMS: l df *ABS* [[#]] chain.s
+# CHECK-SYMS: l F .bolt.org.text [[#]] chain
+# CHECK-SYMS: l F .text.cold [[#]] chain.cold.0
+# CHECK-SYMS: l F .text [[#]] chain
+# CHECK-SYMS: l df *ABS* [[#]] bolt-pseudo.o
+
+# CHECK-REGISTER: BOLT-INFO: marking chain.cold.0/1(*2) as a fragment of chain/2(*2)
+
+.file "chain.s"
+ .text
+ .type chain, @function
+chain:
+ ret
+ .size chain, .-chain

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

@@ -61,19 +61,21 @@ static void addParantheses(const BinaryOperator *BinOp,
  const clang::SourceLocation StartLoc = BinOp->getBeginLoc();
  const clang::SourceLocation EndLoc =
  clang::Lexer::getLocForEndOfToken(BinOp->getEndLoc(), 0, SM, LangOpts);
- if (EndLoc.isInvalid())
- return;
 
- Check->diag(StartLoc,
- "'%0' has higher precedence than '%1'; add parentheses to "
- "explicitly specify the order of operations")
+ auto Diag =
+ Check->diag(StartLoc,
+ "'%0' has higher precedence than '%1'; add parentheses to "
+ "explicitly specify the order of operations")
  << (Precedence1 > Precedence2 ? BinOp->getOpcodeStr()
  : ParentBinOp->getOpcodeStr())
  << (Precedence1 > Precedence2 ? ParentBinOp->getOpcodeStr()
  : BinOp->getOpcodeStr())
- << FixItHint::CreateInsertion(StartLoc, "(")
- << FixItHint::CreateInsertion(EndLoc, ")")
  << SourceRange(StartLoc, EndLoc);
+
+ if (EndLoc.isValid()) {
+ Diag << FixItHint::CreateInsertion(StartLoc, "(")
+ << FixItHint::CreateInsertion(EndLoc, ")");
+ }
  }
 
  addParantheses(dyn_cast<BinaryOperator>(BinOp->getLHS()->IgnoreImpCasts()),

clang-tools-extra/test/clang-tidy/checkers/readability/math-missing-parentheses.cpp

@@ -16,6 +16,13 @@ int bar(){
  return 4;
 }
 
+int sink(int);
+#define FUN(ARG) (sink(ARG))
+#define FUN2(ARG) sink((ARG))
+#define FUN3(ARG) sink(ARG)
+#define FUN4(ARG) sink(1 + ARG)
+#define FUN5(ARG) sink(4 * ARG)
+
 class fun{
 public:
  int A;
@@ -117,4 +124,19 @@ void f(){
  //CHECK-MESSAGES: :[[@LINE+2]]:94: warning: '/' has higher precedence than '-'; add parentheses to explicitly specify the order of operations [readability-math-missing-parentheses]
  //CHECK-FIXES: int q = (1 MACRO_ADD (2 MACRO_MULTIPLY 3)) MACRO_OR ((4 MACRO_AND 5) MACRO_XOR (6 MACRO_SUBTRACT (7 MACRO_DIVIDE 8)));
  int q = 1 MACRO_ADD 2 MACRO_MULTIPLY 3 MACRO_OR 4 MACRO_AND 5 MACRO_XOR 6 MACRO_SUBTRACT 7 MACRO_DIVIDE 8; // No warning
+
+ //CHECK-MESSAGES: :[[@LINE+1]]:21: warning: '*' has higher precedence than '+'; add parentheses to explicitly specify the order of operations [readability-math-missing-parentheses]
+ int r = FUN(0 + 1 * 2);
+
+ //CHECK-MESSAGES: :[[@LINE+1]]:22: warning: '*' has higher precedence than '+'; add parentheses to explicitly specify the order of operations [readability-math-missing-parentheses]
+ int s = FUN2(0 + 1 * 2);
+
+ //CHECK-MESSAGES: :[[@LINE+1]]:22: warning: '*' has higher precedence than '+'; add parentheses to explicitly specify the order of operations [readability-math-missing-parentheses]
+ int t = FUN3(0 + 1 * 2);
+
+ //CHECK-MESSAGES: :[[@LINE+1]]:18: warning: '*' has higher precedence than '+'; add parentheses to explicitly specify the order of operations [readability-math-missing-parentheses]
+ int u = FUN4(1 * 2);
+
+ //CHECK-MESSAGES: :[[@LINE+1]]:13: warning: '*' has higher precedence than '+'; add parentheses to explicitly specify the order of operations [readability-math-missing-parentheses]
+ int v = FUN5(0 + 1);
 }

clang/docs/ReleaseNotes.rst

@@ -261,6 +261,10 @@ New Compiler Flags
 - ``-fexperimental-modules-reduced-bmi`` enables the Reduced BMI for C++20 named modules.
  See the document of standard C++ modules for details.
 
+- ``-fexperimental-late-parse-attributes`` enables an experimental feature to
+ allow late parsing certain attributes in specific contexts where they would
+ not normally be late parsed.
+
 Deprecated Compiler Flags
 -------------------------
 
@@ -612,6 +616,9 @@ Bug Fixes to C++ Support
  immediate function context.
 - Fix CTAD for ``std::initializer_list``. This allows ``std::initializer_list{1, 2, 3}`` to be deduced as
  ``std::initializer_list<int>`` as intended.
+- Fix a bug on template partial specialization whose template parameter is `decltype(auto)`.
+- Fix a bug on template partial specialization with issue on deduction of nontype template parameter
+ whose type is `decltype(auto)`. Fixes (#GH68885).
 
 Bug Fixes to AST Handling
 ^^^^^^^^^^^^^^^^^^^^^^^^^