Merged main:98119718603c6e623b34e3d2160b65b26d9bfcdc into amd-gfx:a22f3eb12095

Local branch amd-gfx a22f3eb Merged main:6de04e6fe8b1520ef3e4073ff222e623b7dc9cb9 into amd-gfx:697d8fbeaade
Remote branch main 9811971 [GitHub] Run format job on stacked PRs (llvm#102957)

Author: SC llvm team

.github/workflows/pr-code-format.yml

@@ -7,6 +7,7 @@ on:
   pull_request:
     branches:
       - main
+      - 'users/**'
 
 jobs:
   code_formatter:

llvm/include/llvm/Config/llvm-config.h.cmake

@@ -16,7 +16,7 @@
 
 /* Indicate that this is LLVM compiled from the amd-gfx branch. */
 #define LLVM_HAVE_BRANCH_AMD_GFX
-#define LLVM_MAIN_REVISION 508409
+#define LLVM_MAIN_REVISION 508411
 
 /* Define if LLVM_ENABLE_DUMP is enabled */
 #cmakedefine LLVM_ENABLE_DUMP

llvm/include/llvm/IR/DataLayout.h

@@ -65,9 +65,6 @@ enum AlignTypeEnum {
 /// Layout alignment element.
 ///
 /// Stores the alignment data associated with a given type bit width.
-///
-/// \note The unusual order of elements in the structure attempts to reduce
-/// padding and make the structure slightly more cache friendly.
 struct LayoutAlignElem {
   uint32_t TypeBitWidth;
   Align ABIAlign;
@@ -82,14 +79,11 @@ struct LayoutAlignElem {
 /// Layout pointer alignment element.
 ///
 /// Stores the alignment data associated with a given pointer and address space.
-///
-/// \note The unusual order of elements in the structure attempts to reduce
-/// padding and make the structure slightly more cache friendly.
 struct PointerAlignElem {
+  uint32_t AddressSpace;
+  uint32_t TypeBitWidth;
   Align ABIAlign;
   Align PrefAlign;
-  uint32_t TypeBitWidth;
-  uint32_t AddressSpace;
   uint32_t IndexBitWidth;
 
   /// Initializer
@@ -115,16 +109,16 @@ class DataLayout {
     MultipleOfFunctionAlign,
   };
 private:
-  /// Defaults to false.
-  bool BigEndian;
+  bool BigEndian = false;
 
-  unsigned AllocaAddrSpace;
-  unsigned ProgramAddrSpace;
-  unsigned DefaultGlobalsAddrSpace;
+  unsigned AllocaAddrSpace = 0;
+  unsigned ProgramAddrSpace = 0;
+  unsigned DefaultGlobalsAddrSpace = 0;
 
   MaybeAlign StackNaturalAlign;
   MaybeAlign FunctionPtrAlign;
-  FunctionPtrAlignType TheFunctionPtrAlignType;
+  FunctionPtrAlignType TheFunctionPtrAlignType =
+      FunctionPtrAlignType::Independent;
 
   enum ManglingModeT {
     MM_None,
@@ -136,24 +130,22 @@ class DataLayout {
     MM_Mips,
     MM_XCOFF
   };
-  ManglingModeT ManglingMode;
+  ManglingModeT ManglingMode = MM_None;
 
   // FIXME: `unsigned char` truncates the value parsed by `parseSpecifier`.
   SmallVector<unsigned char, 8> LegalIntWidths;
 
-  /// Primitive type alignment data. This is sorted by type and bit
-  /// width during construction.
-  using AlignmentsTy = SmallVector<LayoutAlignElem, 4>;
-  AlignmentsTy IntAlignments;
-  AlignmentsTy FloatAlignments;
-  AlignmentsTy VectorAlignments;
+  // Primitive type specifications. Sorted and uniqued by type bit width.
+  SmallVector<LayoutAlignElem, 6> IntAlignments;
+  SmallVector<LayoutAlignElem, 4> FloatAlignments;
+  SmallVector<LayoutAlignElem, 10> VectorAlignments;
+
+  // Pointer type specifications. Sorted and uniqued by address space number.
+  SmallVector<PointerAlignElem, 8> Pointers;
 
   /// The string representation used to create this DataLayout
   std::string StringRepresentation;
 
-  using PointersTy = SmallVector<PointerAlignElem, 8>;
-  PointersTy Pointers;
-
   const PointerAlignElem &getPointerAlignElem(uint32_t AddressSpace) const;
 
   // Struct type ABI and preferred alignments. The default spec is "a:8:64".
@@ -189,6 +181,9 @@ class DataLayout {
   Error parseSpecifier(StringRef Desc);
 
 public:
+  /// Constructs a DataLayout with default values.
+  DataLayout();
+
   /// Constructs a DataLayout from a specification string.
   /// WARNING: Aborts execution if the string is malformed. Use parse() instead.
   explicit DataLayout(StringRef LayoutString);

llvm/lib/IR/DataLayout.cpp

@@ -198,37 +198,38 @@ const char *DataLayout::getManglingComponent(const Triple &T) {
   return "-m:e";
 }
 
-static const std::pair<AlignTypeEnum, LayoutAlignElem> DefaultAlignments[] = {
-    {INTEGER_ALIGN, {1, Align(1), Align(1)}},    // i1
-    {INTEGER_ALIGN, {8, Align(1), Align(1)}},    // i8
-    {INTEGER_ALIGN, {16, Align(2), Align(2)}},   // i16
-    {INTEGER_ALIGN, {32, Align(4), Align(4)}},   // i32
-    {INTEGER_ALIGN, {64, Align(4), Align(8)}},   // i64
-    {FLOAT_ALIGN, {16, Align(2), Align(2)}},     // half, bfloat
-    {FLOAT_ALIGN, {32, Align(4), Align(4)}},     // float
-    {FLOAT_ALIGN, {64, Align(8), Align(8)}},     // double
-    {FLOAT_ALIGN, {128, Align(16), Align(16)}},  // ppcf128, quad, ...
-    {VECTOR_ALIGN, {64, Align(8), Align(8)}},    // v2i32, v1i64, ...
-    {VECTOR_ALIGN, {128, Align(16), Align(16)}}, // v16i8, v8i16, v4i32, ...
+// Default primitive type specifications.
+// NOTE: These arrays must be sorted by type bit width.
+constexpr LayoutAlignElem DefaultIntSpecs[] = {
+    {1, Align::Constant<1>(), Align::Constant<1>()},  // i1:8:8
+    {8, Align::Constant<1>(), Align::Constant<1>()},  // i8:8:8
+    {16, Align::Constant<2>(), Align::Constant<2>()}, // i16:16:16
+    {32, Align::Constant<4>(), Align::Constant<4>()}, // i32:32:32
+    {64, Align::Constant<4>(), Align::Constant<8>()}, // i64:32:64
+};
+constexpr LayoutAlignElem DefaultFloatSpecs[] = {
+    {16, Align::Constant<2>(), Align::Constant<2>()},    // f16:16:16
+    {32, Align::Constant<4>(), Align::Constant<4>()},    // f32:32:32
+    {64, Align::Constant<8>(), Align::Constant<8>()},    // f64:64:64
+    {128, Align::Constant<16>(), Align::Constant<16>()}, // f128:128:128
+};
+constexpr LayoutAlignElem DefaultVectorSpecs[] = {
+    {64, Align::Constant<8>(), Align::Constant<8>()},    // v64:64:64
+    {128, Align::Constant<16>(), Align::Constant<16>()}, // v128:128:128
 };
 
-DataLayout::DataLayout(StringRef LayoutString) {
-  BigEndian = false;
-  AllocaAddrSpace = 0;
-  ProgramAddrSpace = 0;
-  DefaultGlobalsAddrSpace = 0;
-  TheFunctionPtrAlignType = FunctionPtrAlignType::Independent;
-  ManglingMode = MM_None;
-
-  // Default alignments
-  for (const auto &[Kind, Layout] : DefaultAlignments) {
-    if (Error Err = setAlignment(Kind, Layout.ABIAlign, Layout.PrefAlign,
-                                 Layout.TypeBitWidth))
-      report_fatal_error(std::move(Err));
-  }
-  if (Error Err = setPointerAlignmentInBits(0, Align(8), Align(8), 64, 64))
-    report_fatal_error(std::move(Err));
+// Default pointer type specifications.
+constexpr PointerAlignElem DefaultPointerSpecs[] = {
+    {0, 64, Align::Constant<8>(), Align::Constant<8>(), 64} // p0:64:64:64:64
+};
+
+DataLayout::DataLayout()
+    : IntAlignments(ArrayRef(DefaultIntSpecs)),
+      FloatAlignments(ArrayRef(DefaultFloatSpecs)),
+      VectorAlignments(ArrayRef(DefaultVectorSpecs)),
+      Pointers(ArrayRef(DefaultPointerSpecs)) {}
 
+DataLayout::DataLayout(StringRef LayoutString) : DataLayout() {
   if (Error Err = parseSpecifier(LayoutString))
     report_fatal_error(std::move(Err));
 }
@@ -277,7 +278,7 @@ bool DataLayout::operator==(const DataLayout &Other) const {
 }
 
 Expected<DataLayout> DataLayout::parse(StringRef LayoutDescription) {
-  DataLayout Layout("");
+  DataLayout Layout;
   if (Error Err = Layout.parseSpecifier(LayoutDescription))
     return std::move(Err);
   return Layout;

llvm/lib/IR/Module.cpp

@@ -73,7 +73,7 @@ template class llvm::SymbolTableListTraits<GlobalIFunc>;
 
 Module::Module(StringRef MID, LLVMContext &C)
     : Context(C), ValSymTab(std::make_unique<ValueSymbolTable>(-1)),
-      ModuleID(std::string(MID)), SourceFileName(std::string(MID)), DL(""),
+      ModuleID(std::string(MID)), SourceFileName(std::string(MID)),
       IsNewDbgInfoFormat(UseNewDbgInfoFormat) {
   Context.addModule(this);
 }

llvm/unittests/Analysis/ValueLatticeTest.cpp

@@ -22,7 +22,7 @@ namespace {
 class ValueLatticeTest : public testing::Test {
 protected:
   LLVMContext Context;
-  DataLayout DL = DataLayout("");
+  DataLayout DL;
 };
 
 TEST_F(ValueLatticeTest, ValueLatticeGetters) {

llvm/unittests/CodeGen/LowLevelTypeTest.cpp

@@ -20,7 +20,6 @@ namespace {
 
 TEST(LowLevelTypeTest, Token) {
   LLVMContext C;
-  DataLayout DL("");
 
   const LLT TTy = LLT::token();
 
@@ -38,7 +37,7 @@ TEST(LowLevelTypeTest, Token) {
 
 TEST(LowLevelTypeTest, Scalar) {
   LLVMContext C;
-  DataLayout DL("");
+  DataLayout DL;
 
   for (unsigned S : {0U, 1U, 17U, 32U, 64U, 0xfffffU}) {
     const LLT Ty = LLT::scalar(S);
@@ -70,7 +69,7 @@ TEST(LowLevelTypeTest, Scalar) {
 
 TEST(LowLevelTypeTest, Vector) {
   LLVMContext C;
-  DataLayout DL("");
+  DataLayout DL;
 
   for (unsigned S : {0U, 1U, 17U, 32U, 64U, 0xfffU}) {
     for (auto EC :

llvm/unittests/IR/VectorTypesTest.cpp

@@ -276,7 +276,7 @@ TEST(VectorTypesTest, BaseVectorType) {
 
 TEST(VectorTypesTest, FixedLenComparisons) {
   LLVMContext Ctx;
-  DataLayout DL("");
+  DataLayout DL;
 
   Type *Int32Ty = Type::getInt32Ty(Ctx);
   Type *Int64Ty = Type::getInt64Ty(Ctx);
@@ -322,7 +322,7 @@ TEST(VectorTypesTest, FixedLenComparisons) {
 
 TEST(VectorTypesTest, ScalableComparisons) {
   LLVMContext Ctx;
-  DataLayout DL("");
+  DataLayout DL;
 
   Type *Int32Ty = Type::getInt32Ty(Ctx);
   Type *Int64Ty = Type::getInt64Ty(Ctx);