From 61cff9079c083fdcfb9fa324e50b9e480165037e Mon Sep 17 00:00:00 2001 From: serge-sans-paille Date: Thu, 22 Sep 2022 15:01:04 +0200 Subject: [PATCH 001/610] [BOLT] Support building bolt when LLVM_LINK_LLVM_DYLIB is ON This does *not* link with libLLVM, but with static archives instead. Not super-great, but at least the build works, which is probably better than failing. Related to #57551 Differential Revision: https://reviews.llvm.org/D134434 --- bolt/lib/Core/CMakeLists.txt | 1 + bolt/lib/Passes/CMakeLists.txt | 2 ++ bolt/lib/Profile/CMakeLists.txt | 2 ++ bolt/lib/Rewrite/CMakeLists.txt | 2 ++ bolt/lib/RuntimeLibs/CMakeLists.txt | 2 ++ bolt/lib/Target/AArch64/CMakeLists.txt | 2 ++ bolt/lib/Target/X86/CMakeLists.txt | 2 ++ bolt/lib/Utils/CMakeLists.txt | 2 ++ bolt/tools/bat-dump/CMakeLists.txt | 2 ++ bolt/tools/driver/CMakeLists.txt | 2 ++ bolt/tools/heatmap/CMakeLists.txt | 1 + bolt/tools/llvm-bolt-fuzzer/CMakeLists.txt | 2 ++ bolt/tools/merge-fdata/CMakeLists.txt | 2 ++ bolt/unittests/Core/CMakeLists.txt | 2 ++ bolt/unittests/Profile/CMakeLists.txt | 2 ++ 15 files changed, 28 insertions(+) diff --git a/bolt/lib/Core/CMakeLists.txt b/bolt/lib/Core/CMakeLists.txt index 501b5eb6e667..c09a439b1359 100644 --- a/bolt/lib/Core/CMakeLists.txt +++ b/bolt/lib/Core/CMakeLists.txt @@ -24,6 +24,7 @@ add_llvm_library(LLVMBOLTCore ParallelUtilities.cpp Relocation.cpp + DISABLE_LLVM_LINK_LLVM_DYLIB LINK_LIBS ${LLVM_PTHREAD_LIB} ) diff --git a/bolt/lib/Passes/CMakeLists.txt b/bolt/lib/Passes/CMakeLists.txt index c9cb7eb0adb3..544b6dfa74d3 100644 --- a/bolt/lib/Passes/CMakeLists.txt +++ b/bolt/lib/Passes/CMakeLists.txt @@ -45,6 +45,8 @@ add_llvm_library(LLVMBOLTPasses VeneerElimination.cpp RetpolineInsertion.cpp + DISABLE_LLVM_LINK_LLVM_DYLIB + LINK_LIBS ${LLVM_PTHREAD_LIB} diff --git a/bolt/lib/Profile/CMakeLists.txt b/bolt/lib/Profile/CMakeLists.txt index f4397e3314d6..0b5d771d4b9d 100644 --- a/bolt/lib/Profile/CMakeLists.txt +++ b/bolt/lib/Profile/CMakeLists.txt @@ -7,6 +7,8 @@ add_llvm_library(LLVMBOLTProfile YAMLProfileReader.cpp YAMLProfileWriter.cpp + DISABLE_LLVM_LINK_LLVM_DYLIB + LINK_COMPONENTS Support ) diff --git a/bolt/lib/Rewrite/CMakeLists.txt b/bolt/lib/Rewrite/CMakeLists.txt index 053fa9ac15ea..e411c50c05ad 100644 --- a/bolt/lib/Rewrite/CMakeLists.txt +++ b/bolt/lib/Rewrite/CMakeLists.txt @@ -33,6 +33,8 @@ add_llvm_library(LLVMBOLTRewrite MachORewriteInstance.cpp RewriteInstance.cpp + DISABLE_LLVM_LINK_LLVM_DYLIB + LINK_LIBS ${LLVM_PTHREAD_LIB} ) diff --git a/bolt/lib/RuntimeLibs/CMakeLists.txt b/bolt/lib/RuntimeLibs/CMakeLists.txt index f0359a652d39..26c2109982c9 100644 --- a/bolt/lib/RuntimeLibs/CMakeLists.txt +++ b/bolt/lib/RuntimeLibs/CMakeLists.txt @@ -10,6 +10,8 @@ add_llvm_library(LLVMBOLTRuntimeLibs RuntimeLibrary.cpp HugifyRuntimeLibrary.cpp InstrumentationRuntimeLibrary.cpp + + DISABLE_LLVM_LINK_LLVM_DYLIB ) target_link_libraries(LLVMBOLTRuntimeLibs diff --git a/bolt/lib/Target/AArch64/CMakeLists.txt b/bolt/lib/Target/AArch64/CMakeLists.txt index 29753969e85e..be03e247aa96 100644 --- a/bolt/lib/Target/AArch64/CMakeLists.txt +++ b/bolt/lib/Target/AArch64/CMakeLists.txt @@ -7,6 +7,8 @@ set(LLVM_LINK_COMPONENTS add_llvm_library(LLVMBOLTTargetAArch64 AArch64MCPlusBuilder.cpp + DISABLE_LLVM_LINK_LLVM_DYLIB + DEPENDS AArch64CommonTableGen ) diff --git a/bolt/lib/Target/X86/CMakeLists.txt b/bolt/lib/Target/X86/CMakeLists.txt index 7be9f80006c6..2b769bc7e7f5 100644 --- a/bolt/lib/Target/X86/CMakeLists.txt +++ b/bolt/lib/Target/X86/CMakeLists.txt @@ -9,6 +9,8 @@ add_llvm_library(LLVMBOLTTargetX86 X86MCPlusBuilder.cpp X86MCSymbolizer.cpp + DISABLE_LLVM_LINK_LLVM_DYLIB + DEPENDS X86CommonTableGen ) diff --git a/bolt/lib/Utils/CMakeLists.txt b/bolt/lib/Utils/CMakeLists.txt index 2a1307750b9f..9ed9be6e1d85 100644 --- a/bolt/lib/Utils/CMakeLists.txt +++ b/bolt/lib/Utils/CMakeLists.txt @@ -2,6 +2,8 @@ add_llvm_library(LLVMBOLTUtils CommandLineOpts.cpp Utils.cpp + DISABLE_LLVM_LINK_LLVM_DYLIB + LINK_LIBS ${LLVM_PTHREAD_LIB} diff --git a/bolt/tools/bat-dump/CMakeLists.txt b/bolt/tools/bat-dump/CMakeLists.txt index b7a7c45e9689..71d4f3e64ccd 100644 --- a/bolt/tools/bat-dump/CMakeLists.txt +++ b/bolt/tools/bat-dump/CMakeLists.txt @@ -5,6 +5,8 @@ set(LLVM_LINK_COMPONENTS add_llvm_tool(llvm-bat-dump bat-dump.cpp + + DISABLE_LLVM_LINK_LLVM_DYLIB ) target_link_libraries(llvm-bat-dump diff --git a/bolt/tools/driver/CMakeLists.txt b/bolt/tools/driver/CMakeLists.txt index e56be15dbcff..1c596194ffe8 100644 --- a/bolt/tools/driver/CMakeLists.txt +++ b/bolt/tools/driver/CMakeLists.txt @@ -14,6 +14,8 @@ endif() add_bolt_tool(llvm-bolt llvm-bolt.cpp + DISABLE_LLVM_LINK_LLVM_DYLIB + DEPENDS ${BOLT_DRIVER_DEPS} ) diff --git a/bolt/tools/heatmap/CMakeLists.txt b/bolt/tools/heatmap/CMakeLists.txt index cb8e7ee2605c..9f52ddb02102 100644 --- a/bolt/tools/heatmap/CMakeLists.txt +++ b/bolt/tools/heatmap/CMakeLists.txt @@ -7,6 +7,7 @@ set(LLVM_LINK_COMPONENTS add_bolt_tool(llvm-bolt-heatmap heatmap.cpp + DISABLE_LLVM_LINK_LLVM_DYLIB ) target_link_libraries(llvm-bolt-heatmap diff --git a/bolt/tools/llvm-bolt-fuzzer/CMakeLists.txt b/bolt/tools/llvm-bolt-fuzzer/CMakeLists.txt index f84a841a163d..f21285f634ba 100644 --- a/bolt/tools/llvm-bolt-fuzzer/CMakeLists.txt +++ b/bolt/tools/llvm-bolt-fuzzer/CMakeLists.txt @@ -4,6 +4,8 @@ set(LLVM_LINK_COMPONENTS add_llvm_fuzzer(llvm-bolt-fuzzer llvm-bolt-fuzzer.cpp + + DISABLE_LLVM_LINK_LLVM_DYLIB ) if (TARGET llvm-bolt-fuzzer) diff --git a/bolt/tools/merge-fdata/CMakeLists.txt b/bolt/tools/merge-fdata/CMakeLists.txt index 08b2e65b1bce..4bd2b522b8f9 100644 --- a/bolt/tools/merge-fdata/CMakeLists.txt +++ b/bolt/tools/merge-fdata/CMakeLists.txt @@ -3,6 +3,8 @@ set(LLVM_LINK_COMPONENTS Support) add_bolt_tool(merge-fdata merge-fdata.cpp + DISABLE_LLVM_LINK_LLVM_DYLIB + DEPENDS intrinsics_gen ) diff --git a/bolt/unittests/Core/CMakeLists.txt b/bolt/unittests/Core/CMakeLists.txt index 0e78d0a2746f..15d48f2c422c 100644 --- a/bolt/unittests/Core/CMakeLists.txt +++ b/bolt/unittests/Core/CMakeLists.txt @@ -9,6 +9,8 @@ add_bolt_unittest(CoreTests BinaryContext.cpp MCPlusBuilder.cpp DynoStats.cpp + + DISABLE_LLVM_LINK_LLVM_DYLIB ) target_link_libraries(CoreTests diff --git a/bolt/unittests/Profile/CMakeLists.txt b/bolt/unittests/Profile/CMakeLists.txt index b0f1ec0f8045..e0aa0926b49c 100644 --- a/bolt/unittests/Profile/CMakeLists.txt +++ b/bolt/unittests/Profile/CMakeLists.txt @@ -1,5 +1,7 @@ add_bolt_unittest(ProfileTests DataAggregator.cpp + + DISABLE_LLVM_LINK_LLVM_DYLIB ) target_link_libraries(ProfileTests From 3fe71809a5d666385575358b579aae2b8a96dd07 Mon Sep 17 00:00:00 2001 From: Yashwant Singh Date: Fri, 23 Sep 2022 11:11:39 +0530 Subject: [PATCH 002/610] Introduce predicate for a atomic operations in GMIR Reviewed By: arsenm, sameerds Differential Revision: https://reviews.llvm.org/D134266 --- llvm/include/llvm/CodeGen/TargetInstrInfo.h | 5 +++++ llvm/include/llvm/Support/TargetOpcodes.def | 6 ++++++ 2 files changed, 11 insertions(+) diff --git a/llvm/include/llvm/CodeGen/TargetInstrInfo.h b/llvm/include/llvm/CodeGen/TargetInstrInfo.h index 65fba772c0c8..02eaf93f350e 100644 --- a/llvm/include/llvm/CodeGen/TargetInstrInfo.h +++ b/llvm/include/llvm/CodeGen/TargetInstrInfo.h @@ -110,6 +110,11 @@ class TargetInstrInfo : public MCInstrInfo { return Opc <= TargetOpcode::GENERIC_OP_END; } + static bool isGenericAtomicRMWOpcode(unsigned Opc) { + return Opc >= TargetOpcode::GENERIC_ATOMICRMW_OP_START && + Opc <= TargetOpcode::GENERIC_ATOMICRMW_OP_END; + } + /// Given a machine instruction descriptor, returns the register /// class constraint for OpNum, or NULL. virtual diff --git a/llvm/include/llvm/Support/TargetOpcodes.def b/llvm/include/llvm/Support/TargetOpcodes.def index 5d6be0fe655e..52da5659e805 100644 --- a/llvm/include/llvm/Support/TargetOpcodes.def +++ b/llvm/include/llvm/Support/TargetOpcodes.def @@ -387,6 +387,12 @@ HANDLE_TARGET_OPCODE(G_ATOMICRMW_FSUB) HANDLE_TARGET_OPCODE(G_ATOMICRMW_FMAX) HANDLE_TARGET_OPCODE(G_ATOMICRMW_FMIN) +// Marker for start of Generic AtomicRMW opcodes +HANDLE_TARGET_OPCODE_MARKER(GENERIC_ATOMICRMW_OP_START, G_ATOMICRMW_XCHG) + +// Marker for end of Generic AtomicRMW opcodes +HANDLE_TARGET_OPCODE_MARKER(GENERIC_ATOMICRMW_OP_END, G_ATOMICRMW_FMIN) + // Generic atomic fence HANDLE_TARGET_OPCODE(G_FENCE) From c0185c8d296d6bc8cdcf211fdc19a89afa8e3222 Mon Sep 17 00:00:00 2001 From: Valentin Clement Date: Fri, 23 Sep 2022 07:06:33 +0200 Subject: [PATCH 003/610] [flang] Load allocatable or pointer box of namelist item from common block If a namelist item is an allocatable or pointer and is also part of a common block, the box should be loaded from the common block ref. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D134470 --- flang/lib/Lower/IO.cpp | 21 ++++++++++++++++ flang/test/Lower/namelist-common-block.f90 | 29 ++++++++++++++++++++++ 2 files changed, 50 insertions(+) create mode 100644 flang/test/Lower/namelist-common-block.f90 diff --git a/flang/lib/Lower/IO.cpp b/flang/lib/Lower/IO.cpp index 505a2d748628..e207b50f7957 100644 --- a/flang/lib/Lower/IO.cpp +++ b/flang/lib/Lower/IO.cpp @@ -12,6 +12,7 @@ #include "flang/Lower/IO.h" #include "flang/Common/uint128.h" +#include "flang/Evaluate/tools.h" #include "flang/Lower/Allocatable.h" #include "flang/Lower/Bridge.h" #include "flang/Lower/ConvertExpr.h" @@ -321,6 +322,26 @@ getNamelistGroup(Fortran::lower::AbstractConverter &converter, builder.getNamedGlobal(converter.mangleName(s) + suffix)) { descAddr = builder.create(loc, desc.resultType(), desc.getSymbol()); + } else if (Fortran::semantics::FindCommonBlockContaining(s) && + IsAllocatableOrPointer(s)) { + mlir::Type symType = converter.genType(s); + const Fortran::semantics::Symbol *commonBlockSym = + Fortran::semantics::FindCommonBlockContaining(s); + std::string commonBlockName = converter.mangleName(*commonBlockSym); + fir::GlobalOp commonGlobal = builder.getNamedGlobal(commonBlockName); + mlir::Value commonBlockAddr = builder.create( + loc, commonGlobal.resultType(), commonGlobal.getSymbol()); + mlir::IntegerType i8Ty = builder.getIntegerType(8); + mlir::Type i8Ptr = builder.getRefType(i8Ty); + mlir::Type seqTy = builder.getRefType(builder.getVarLenSeqTy(i8Ty)); + mlir::Value base = builder.createConvert(loc, seqTy, commonBlockAddr); + std::size_t byteOffset = s.GetUltimate().offset(); + mlir::Value offs = builder.createIntegerConstant( + loc, builder.getIndexType(), byteOffset); + mlir::Value varAddr = builder.create( + loc, i8Ptr, base, mlir::ValueRange{offs}); + descAddr = + builder.createConvert(loc, builder.getRefType(symType), varAddr); } else { const auto expr = Fortran::evaluate::AsGenericExpr(s); fir::ExtendedValue exv = converter.genExprAddr(*expr, stmtCtx); diff --git a/flang/test/Lower/namelist-common-block.f90 b/flang/test/Lower/namelist-common-block.f90 new file mode 100644 index 000000000000..f0362d7f6143 --- /dev/null +++ b/flang/test/Lower/namelist-common-block.f90 @@ -0,0 +1,29 @@ +! RUN: bbc -emit-fir -o - %s | FileCheck %s + +! Test that allocatable or pointer item from namelist are retrieved correctly +! if they are part of a common block as well. + +program nml_common + integer :: i + real, pointer :: p(:) + namelist /t/i,p + common /c/i,p + + allocate(p(2)) + call print_t() +contains + subroutine print_t() + write(*,t) + end subroutine +end + +! CHECK-LABEL: fir.global linkonce @_QFGt.list constant : !fir.array<2xtuple, !fir.ref>>> { +! CHECK: %[[CB_ADDR:.*]] = fir.address_of(@_QBc) : !fir.ref> +! CHECK: %[[CB_CAST:.*]] = fir.convert %[[CB_ADDR]] : (!fir.ref>) -> !fir.ref> +! CHECK: %[[OFFSET:.*]] = arith.constant 8 : index +! CHECK: %[[COORD:.*]] = fir.coordinate_of %[[CB_CAST]], %[[OFFSET]] : (!fir.ref>, index) -> !fir.ref +! CHECK: %[[CAST_BOX:.*]] = fir.convert %[[COORD]] : (!fir.ref) -> !fir.ref>>> +! CHECK: %[[CAST_BOX_NONE:.*]] = fir.convert %[[CAST_BOX]] : (!fir.ref>>>) -> !fir.ref> +! CHECK: %[[RES:.*]] = fir.insert_value %{{.*}}, %[[CAST_BOX_NONE]], [1 : index, 1 : index] : (!fir.array<2xtuple, !fir.ref>>>, !fir.ref>) -> !fir.array<2xtuple, !fir.ref>>> +! CHECK: fir.has_value %[[RES]] : !fir.array<2xtuple, !fir.ref>>> + From c965ffa1ed9346f058280f8444b1d2792491bd30 Mon Sep 17 00:00:00 2001 From: Alexey Lapshin Date: Mon, 5 Sep 2022 17:33:22 +0300 Subject: [PATCH 004/610] [llvm-dwarfutil][DWARFv5] fix reading of DW_FORM_addrx attribute. llvm::dwarfutil::ObjFileAddressMap::relocateIndexedAddr() does not read address value. The relocateIndexedAddr() should not relocate the address as the linked binary has already resolved relocations. But it should read the value. This patch adds the reading value of the address. Differential Revision: https://reviews.llvm.org/D133324 --- .../llvm-dwarfutil/ELF/X86/dwarf5-addrx.test | 120 ++++++++++++++++++ llvm/tools/llvm-dwarfutil/DebugInfoLinker.cpp | 29 ++++- 2 files changed, 145 insertions(+), 4 deletions(-) create mode 100644 llvm/test/tools/llvm-dwarfutil/ELF/X86/dwarf5-addrx.test diff --git a/llvm/test/tools/llvm-dwarfutil/ELF/X86/dwarf5-addrx.test b/llvm/test/tools/llvm-dwarfutil/ELF/X86/dwarf5-addrx.test new file mode 100644 index 000000000000..20964f99801a --- /dev/null +++ b/llvm/test/tools/llvm-dwarfutil/ELF/X86/dwarf5-addrx.test @@ -0,0 +1,120 @@ +## Test that DWARF5 DW_FORM_addrx is correctly recognized +## and converted into the DW_FORM_addr + +# RUN: yaml2obj %s -o %t.o + +# RUN: llvm-dwarfutil %t.o %t1 +# RUN: llvm-dwarfdump -verify %t1 | FileCheck %s +# RUN: llvm-dwarfdump -a --verbose %t1 | FileCheck %s --check-prefix DWARF-CHECK + +#CHECK: No errors. + +#DWARF-CHECK: DW_TAG_compile_unit +#DWARF-CHECK: DW_AT_name [DW_FORM_strp] {{.*}} "CU1" +#DWARF-CHECK: DW_AT_low_pc [DW_FORM_addr] (0x0000000000001130) +#DWARF-CHECK: DW_AT_high_pc [DW_FORM_data8] (0x0000000000000030) +#DWARF-CHECK: DW_AT_addr_base [DW_FORM_sec_offset] (0x00000008) +#DWARF-CHECK: DW_TAG_subprogram +#DWARF-CHECK: DW_AT_name [DW_FORM_strp] {{.*}} "foo1" +#DWARF-CHECK: DW_AT_low_pc [DW_FORM_addr] (0x0000000000001130) +#DWARF-CHECK: DW_AT_high_pc [DW_FORM_data8] (0x0000000000000010) +#DWARF-CHECK: DW_TAG_subprogram +#DWARF-CHECK: DW_AT_name [DW_FORM_strp] {{.*}} "foo2" +#DWARF-CHECK: DW_AT_low_pc [DW_FORM_addr] (0x0000000000001140) +#DWARF-CHECK: DW_AT_high_pc [DW_FORM_data8] (0x0000000000000010) +#DWARF-CHECK: DW_TAG_subprogram +#DWARF-CHECK: DW_AT_name [DW_FORM_strp] {{.*}} "foo3" +#DWARF-CHECK: DW_AT_low_pc [DW_FORM_addr] (0x0000000000001150) +#DWARF-CHECK: DW_AT_high_pc [DW_FORM_data8] (0x0000000000000010) + +--- !ELF +FileHeader: + Class: ELFCLASS64 + Data: ELFDATA2LSB + Type: ET_REL + Machine: EM_X86_64 +Sections: + - Name: .text + Type: SHT_PROGBITS + Flags: [ SHF_ALLOC, SHF_EXECINSTR ] + Address: 0x1130 + Size: 0x30 +DWARF: + debug_abbrev: + - Table: + - Tag: DW_TAG_compile_unit + Children: DW_CHILDREN_yes + Attributes: + - Attribute: DW_AT_producer + Form: DW_FORM_string + - Attribute: DW_AT_language + Form: DW_FORM_data2 + - Attribute: DW_AT_name + Form: DW_FORM_string + - Attribute: DW_AT_low_pc + Form: DW_FORM_addrx + - Attribute: DW_AT_high_pc + Form: DW_FORM_data8 + - Attribute: DW_AT_addr_base + Form: DW_FORM_sec_offset + - Tag: DW_TAG_subprogram + Children: DW_CHILDREN_yes + Attributes: + - Attribute: DW_AT_name + Form: DW_FORM_string + - Attribute: DW_AT_low_pc + Form: DW_FORM_addrx + - Attribute: DW_AT_high_pc + Form: DW_FORM_data8 + - Attribute: DW_AT_type + Form: DW_FORM_ref4 + - Tag: DW_TAG_base_type + Children: DW_CHILDREN_no + Attributes: + - Attribute: DW_AT_name + Form: DW_FORM_string + debug_info: + - Version: 5 + UnitType: DW_UT_compile + Entries: + - AbbrCode: 1 + Values: + - CStr: by_hand + - Value: 0x04 + - CStr: CU1 + - Value: 0x0 + - Value: 0x30 + - Value: 0x8 + - AbbrCode: 2 + Values: + - CStr: foo1 + - Value: 0x0 + - Value: 0x10 + - Value: 0x64 + - AbbrCode: 0 + - AbbrCode: 2 + Values: + - CStr: foo2 + - Value: 0x01 + - Value: 0x10 + - Value: 0x64 + - AbbrCode: 0 + - AbbrCode: 2 + Values: + - CStr: foo3 + - Value: 0x02 + - Value: 0x10 + - Value: 0x64 + - AbbrCode: 0 + - AbbrCode: 3 + Values: + - CStr: int + - AbbrCode: 0 + debug_addr: + - Version: 5 + AddressSize: 0x08 + Entries: + - Address: 0x1130 + - Address: 0x1140 + - Address: 0x1150 +... diff --git a/llvm/tools/llvm-dwarfutil/DebugInfoLinker.cpp b/llvm/tools/llvm-dwarfutil/DebugInfoLinker.cpp index df17b010a7c3..5b1ded885cd5 100644 --- a/llvm/tools/llvm-dwarfutil/DebugInfoLinker.cpp +++ b/llvm/tools/llvm-dwarfutil/DebugInfoLinker.cpp @@ -14,6 +14,7 @@ #include "llvm/DebugInfo/DWARF/DWARFContext.h" #include "llvm/DebugInfo/DWARF/DWARFExpression.h" #include "llvm/Object/ObjectFile.h" +#include "llvm/Support/Endian.h" #include #include @@ -40,7 +41,7 @@ class ObjFileAddressMap : public AddressesMap { public: ObjFileAddressMap(DWARFContext &Context, const Options &Options, object::ObjectFile &ObjFile) - : Opts(Options) { + : Opts(Options), Context(Context) { // Remember addresses of existing text sections. for (const object::SectionRef &Sect : ObjFile.sections()) { if (!Sect.isText()) @@ -137,9 +138,28 @@ class ObjFileAddressMap : public AddressesMap { void clear() override { DWARFAddressRanges.clear(); } - llvm::Expected relocateIndexedAddr(uint64_t, uint64_t) override { - // should not be called. - return object::createError("no relocations in linked binary"); + llvm::Expected relocateIndexedAddr(uint64_t StartOffset, + uint64_t EndOffset) override { + // No relocations in linked binary. Return just address value. + + const char *AddrPtr = + Context.getDWARFObj().getAddrSection().Data.data() + StartOffset; + support::endianness Endianess = + Context.getDWARFObj().isLittleEndian() ? support::little : support::big; + + assert(EndOffset > StartOffset); + switch (EndOffset - StartOffset) { + case 1: + return *AddrPtr; + case 2: + return support::endian::read16(AddrPtr, Endianess); + case 4: + return support::endian::read32(AddrPtr, Endianess); + case 8: + return support::endian::read64(AddrPtr, Endianess); + } + + llvm_unreachable("relocateIndexedAddr unhandled case!"); } protected: @@ -209,6 +229,7 @@ class ObjFileAddressMap : public AddressesMap { RangesTy DWARFAddressRanges; AddressRanges TextAddressRanges; const Options &Opts; + DWARFContext &Context; }; static bool knownByDWARFUtil(StringRef SecName) { From 1aaba40dcbe8fdc93d825d1f4e22edaa3e9aa5b1 Mon Sep 17 00:00:00 2001 From: Chuanqi Xu Date: Fri, 23 Sep 2022 15:17:35 +0800 Subject: [PATCH 005/610] [C++] [Modules] Add a test case for mocking implementation for std modules I found this with the patch: https://reviews.llvm.org/D131858. It breaks my local implementation but not the in-tree test cases. So I reduce the failure and submit the test case. The more testing should be always good. --- clang/test/Modules/pair-unambiguous-ctor.cppm | 265 ++++++++++++++++++ 1 file changed, 265 insertions(+) create mode 100644 clang/test/Modules/pair-unambiguous-ctor.cppm diff --git a/clang/test/Modules/pair-unambiguous-ctor.cppm b/clang/test/Modules/pair-unambiguous-ctor.cppm new file mode 100644 index 000000000000..8022f34f3aaf --- /dev/null +++ b/clang/test/Modules/pair-unambiguous-ctor.cppm @@ -0,0 +1,265 @@ +// Test case reduced from an experimental std modules implementation. +// Tests that the compiler don't emit confusing error about the ambiguous ctor +// about std::pair. +// +// RUN: rm -fr %t +// RUN: mkdir %t +// RUN: split-file %s %t +// +// RUN: %clang_cc1 -std=c++20 %t/string.cppm -I%t -emit-module-interface -o %t/std-string.pcm +// RUN: %clang_cc1 -std=c++20 %t/algorithm.cppm -I%t -emit-module-interface -o %t/std-algorithm.pcm +// RUN: %clang_cc1 -std=c++20 %t/Use.cppm -I%t -fprebuilt-module-path=%t -emit-module-interface -verify -o %t/Use.pcm + +//--- Use.cppm +// expected-no-diagnostics +module; +#include "config.h" +export module std:M; +import :string; +import :algorithm; + +auto check() { + return std::string(); +} + +//--- string.cppm +module; +#include "string.h" +export module std:string; +export namespace std { + using std::string; +} + +//--- algorithm.cppm +module; +#include "algorithm.h" +export module std:algorithm; + +//--- pair.h +namespace std __attribute__ ((__visibility__ ("default"))) +{ + typedef long unsigned int size_t; + typedef long int ptrdiff_t; + + typedef decltype(nullptr) nullptr_t; + + template + struct integral_constant + { + static constexpr _Tp value = __v; + typedef _Tp value_type; + typedef integral_constant<_Tp, __v> type; + constexpr operator value_type() const noexcept { return value; } + constexpr value_type operator()() const noexcept { return value; } + }; + + template + constexpr _Tp integral_constant<_Tp, __v>::value; + + typedef integral_constant true_type; + typedef integral_constant false_type; + + template + using __bool_constant = integral_constant; + + + template + struct conditional; + + template + struct conditional + { typedef _Iftrue type; }; + + template + struct conditional + { typedef _Iffalse type; }; + + + template + struct enable_if + { }; + + + template + struct enable_if + { typedef _Tp type; }; + + template + struct __is_constructible_impl + : public __bool_constant<__is_constructible(_Tp, _Args...)> + { }; + + + template + struct is_constructible + : public __is_constructible_impl<_Tp, _Args...> + {}; + + template + struct __is_void_helper + : public false_type { }; + + template<> + struct __is_void_helper + : public true_type { }; + + template + struct is_void + : public __is_void_helper<_Tp>::type + { }; + + template + class tuple; + + template + struct _Index_tuple; + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return is_constructible<_T1, const _U1&>::value; + } + + }; + + template + struct pair + { + typedef _T1 first_type; + typedef _T2 second_type; + + _T1 first; + _T2 second; + + using _PCCP = _PCC; + + template(), + bool>::type=true> + constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + constexpr pair& + operator=(typename conditional< + is_constructible<_T2>::value, + const pair&, nullptr_t>::type __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + private: + template + constexpr + pair(tuple<_Args1...>&, tuple<_Args2...>&, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); + + }; + + template pair(_T1, _T2) -> pair<_T1, _T2>; +} + +//--- string.h +#include "pair.h" + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + class __undefined; + + template + using __make_not_void + = typename conditional::value, __undefined, _Tp>::type; + + template + struct pointer_traits {}; + + template + struct pointer_traits<_Tp*> + { + + typedef _Tp* pointer; + + typedef _Tp element_type; + + static constexpr pointer + pointer_to(__make_not_void& __r) noexcept + { return __builtin_addressof(__r); } + }; + + template + class allocator; + + template + struct allocator_traits; + + template + struct allocator_traits> + { + using pointer = _Tp*; + }; + + template + struct __alloc_traits + : std::allocator_traits<_Alloc> + { + typedef std::allocator_traits<_Alloc> _Base_type; + typedef typename _Base_type::pointer pointer; + }; + + template + struct char_traits; + + template, + typename _Alloc = allocator<_CharT> > + class basic_string + { + typedef std::__alloc_traits<_Alloc> _Alloc_traits; + + public: + typedef typename _Alloc_traits::pointer pointer; + + private: + pointer _M_dataplus; + _CharT _M_local_buf[16]; + + pointer + _M_local_data() + { + return std::pointer_traits::pointer_to(*_M_local_buf); + } + public: + basic_string() + : _M_dataplus(_M_local_data()) + { } + + }; + + typedef basic_string string; +} + +//--- algorithm.h +#include "pair.h" +namespace std { + struct _Power2_rehash_policy + { + std::pair + _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt, + std::size_t __n_ins) noexcept + { + return { false, 0 }; + } + }; +} + +//--- config.h +namespace std +{ + typedef __SIZE_TYPE__ size_t; +} + From 3dab7fede2019c399d793c43ca9ea5a4f2d5031f Mon Sep 17 00:00:00 2001 From: Amir Ayupov Date: Fri, 23 Sep 2022 10:08:58 +0200 Subject: [PATCH 006/610] [CMake] Add clang-bolt target This patch adds `CLANG_BOLT_INSTRUMENT` option that applies BOLT instrumentation to Clang, performs a bootstrap build with the resulting Clang, merges resulting fdata files into a single profile file, and uses it to perform BOLT optimization on the original Clang binary. The projects and targets used for bootstrap/profile collection are configurable via `CLANG_BOLT_INSTRUMENT_PROJECTS` and `CLANG_BOLT_INSTRUMENT_TARGETS`. The defaults are "llvm" and "count" respectively, which results in a profile with ~5.3B dynamically executed instructions. The intended use of the functionality is through BOLT CMake cache file, similar to PGO 2-stage build: ``` cmake /llvm -C /clang/cmake/caches/BOLT.cmake ninja clang++-bolt # pulls clang-bolt ``` Stats with a recent checkout (clang-16), pre-built BOLT and Clang, 72vCPU/224G | CMake configure with host Clang + BOLT.cmake | 1m6.592s | Instrumenting Clang with BOLT | 2m50.508s | CMake configure `llvm` with instrumented Clang | 5m46.364s (~5x slowdown) | CMake build `not` with instrumented Clang |0m6.456s | Merging fdata files | 0m9.439s | Optimizing Clang with BOLT | 0m39.201s Building Clang: ```cmake ../llvm-project/llvm -DCMAKE_C_COMPILER=... -DCMAKE_CXX_COMPILER=... -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_PROJECTS=clang -DLLVM_TARGETS_TO_BUILD=Native -GNinja``` | | Release | BOLT-optimized | cmake | 0m24.016s | 0m22.333s | ninja clang | 5m55.692s | 4m35.122s I know it's not rigorous, but shows a ballpark figure. Reviewed By: phosek Differential Revision: https://reviews.llvm.org/D132975 --- clang/CMakeLists.txt | 114 ++++++++++++++++++++++- clang/cmake/caches/BOLT.cmake | 15 +++ clang/utils/perf-training/perf-helper.py | 18 +++- 3 files changed, 143 insertions(+), 4 deletions(-) create mode 100644 clang/cmake/caches/BOLT.cmake diff --git a/clang/CMakeLists.txt b/clang/CMakeLists.txt index 02ce5de4652d..22b5118c83ed 100644 --- a/clang/CMakeLists.txt +++ b/clang/CMakeLists.txt @@ -443,7 +443,7 @@ CMAKE_DEPENDENT_OPTION(CLANG_PLUGIN_SUPPORT "HAVE_CLANG_PLUGIN_SUPPORT" OFF) # If libstdc++ is statically linked, clang-repl needs to statically link libstdc++ -# itself, which is not possible in many platforms because of current limitations in +# itself, which is not possible in many platforms because of current limitations in # JIT stack. (more platforms need to be supported by JITLink) if(NOT LLVM_STATIC_LINK_CXX_STDLIB) set(HAVE_CLANG_REPL_SUPPORT ON) @@ -881,6 +881,118 @@ if (CLANG_ENABLE_BOOTSTRAP) endforeach() endif() +if (CLANG_BOLT_INSTRUMENT) + set(CLANG_PATH ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang) + set(CLANGXX_PATH ${CLANG_PATH}++) + set(CLANG_INSTRUMENTED ${CLANG_PATH}-bolt.inst) + set(CLANGXX_INSTRUMENTED ${CLANGXX_PATH}-bolt.inst) + set(CLANG_OPTIMIZED ${CLANG_PATH}-bolt) + set(CLANGXX_OPTIMIZED ${CLANGXX_PATH}-bolt) + + # Instrument clang with BOLT + add_custom_target(clang-instrumented + DEPENDS ${CLANG_INSTRUMENTED} + ) + add_custom_command(OUTPUT ${CLANG_INSTRUMENTED} + DEPENDS clang llvm-bolt + COMMAND llvm-bolt ${CLANG_PATH} -o ${CLANG_INSTRUMENTED} + -instrument --instrumentation-file-append-pid + --instrumentation-file=${CMAKE_CURRENT_BINARY_DIR}/prof.fdata + COMMENT "Instrumenting clang binary with BOLT" + VERBATIM + ) + + # Make a symlink from clang-bolt.inst to clang++-bolt.inst + add_custom_target(clang++-instrumented + DEPENDS ${CLANGXX_INSTRUMENTED} + ) + add_custom_command(OUTPUT ${CLANGXX_INSTRUMENTED} + DEPENDS clang-instrumented + COMMAND ${CMAKE_COMMAND} -E create_symlink + ${CLANG_INSTRUMENTED} + ${CLANGXX_INSTRUMENTED} + COMMENT "Creating symlink from BOLT instrumented clang to clang++" + VERBATIM + ) + + # Build specified targets with instrumented Clang to collect the profile + set(STAMP_DIR ${CMAKE_CURRENT_BINARY_DIR}/bolt-instrumented-clang-stamps/) + set(BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/bolt-instrumented-clang-bins/) + set(build_configuration "$") + include(ExternalProject) + ExternalProject_Add(bolt-instrumentation-profile + DEPENDS clang++-instrumented + PREFIX bolt-instrumentation-profile + SOURCE_DIR ${CMAKE_SOURCE_DIR} + STAMP_DIR ${STAMP_DIR} + BINARY_DIR ${BINARY_DIR} + EXCLUDE_FROM_ALL 1 + CMAKE_ARGS + ${CLANG_BOLT_INSTRUMENT_EXTRA_CMAKE_FLAGS} + # We shouldn't need to set this here, but INSTALL_DIR doesn't + # seem to work, so instead I'm passing this through + -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX} + -DCMAKE_C_COMPILER=${CLANG_INSTRUMENTED} + -DCMAKE_CXX_COMPILER=${CLANGXX_INSTRUMENTED} + -DCMAKE_ASM_COMPILER=${CLANG_INSTRUMENTED} + -DCMAKE_ASM_COMPILER_ID=Clang + -DCMAKE_BUILD_TYPE=Release + -DLLVM_ENABLE_PROJECTS=${CLANG_BOLT_INSTRUMENT_PROJECTS} + -DLLVM_TARGETS_TO_BUILD=${LLVM_TARGETS_TO_BUILD} + BUILD_COMMAND ${CMAKE_COMMAND} --build ${BINARY_DIR} + --config ${build_configuration} + --target ${CLANG_BOLT_INSTRUMENT_TARGETS} + INSTALL_COMMAND "" + STEP_TARGETS configure build + USES_TERMINAL_CONFIGURE 1 + USES_TERMINAL_BUILD 1 + USES_TERMINAL_INSTALL 1 + ) + + # Merge profiles into one using merge-fdata + add_custom_target(clang-bolt-profile + DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/prof.fdata + ) + add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/prof.fdata + DEPENDS merge-fdata bolt-instrumentation-profile-build + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + COMMAND ${Python3_EXECUTABLE} + ${CMAKE_CURRENT_SOURCE_DIR}/utils/perf-training/perf-helper.py merge-fdata + $ ${CMAKE_CURRENT_BINARY_DIR}/prof.fdata + ${CMAKE_CURRENT_BINARY_DIR} + COMMENT "Preparing BOLT profile" + VERBATIM + ) + + # Optimize original (pre-bolt) Clang using the collected profile + add_custom_target(clang-bolt + DEPENDS ${CLANG_OPTIMIZED} + ) + add_custom_command(OUTPUT ${CLANG_OPTIMIZED} + DEPENDS clang-bolt-profile + COMMAND llvm-bolt ${CLANG_PATH} + -o ${CLANG_OPTIMIZED} + -data ${CMAKE_CURRENT_BINARY_DIR}/prof.fdata + -reorder-blocks=ext-tsp -reorder-functions=hfsort+ -split-functions + -split-all-cold -split-eh -dyno-stats -icf=1 -use-gnu-stack + COMMENT "Optimizing Clang with BOLT" + VERBATIM + ) + + # Make a symlink from clang-bolt to clang++-bolt + add_custom_target(clang++-bolt + DEPENDS ${CLANGXX_OPTIMIZED} + ) + add_custom_command(OUTPUT ${CLANGXX_OPTIMIZED} + DEPENDS clang-bolt + COMMAND ${CMAKE_COMMAND} -E create_symlink + ${CLANG_OPTIMIZED} + ${CLANGXX_OPTIMIZED} + COMMENT "Creating symlink from BOLT optimized clang to clang++" + VERBATIM + ) +endif() + if (LLVM_ADD_NATIVE_VISUALIZERS_TO_SOLUTION) add_subdirectory(utils/ClangVisualizers) endif() diff --git a/clang/cmake/caches/BOLT.cmake b/clang/cmake/caches/BOLT.cmake new file mode 100644 index 000000000000..65444c8044c3 --- /dev/null +++ b/clang/cmake/caches/BOLT.cmake @@ -0,0 +1,15 @@ +set(CMAKE_BUILD_TYPE Release CACHE STRING "") +set(CLANG_BOLT_INSTRUMENT ON CACHE BOOL "") +set(CLANG_BOLT_INSTRUMENT_PROJECTS "llvm" CACHE STRING "") +set(CLANG_BOLT_INSTRUMENT_TARGETS "count" CACHE STRING "") +set(CMAKE_EXE_LINKER_FLAGS "-Wl,--emit-relocs,-znow" CACHE STRING "") +set(CLANG_BOLT_INSTRUMENT_EXTRA_CMAKE_FLAGS "" CACHE STRING "") + +set(LLVM_ENABLE_PROJECTS "bolt;clang" CACHE STRING "") +set(LLVM_TARGETS_TO_BUILD Native CACHE STRING "") + +# Disable function splitting enabled by default in GCC8+ +if("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-reorder-blocks-and-partition") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-reorder-blocks-and-partition") +endif() diff --git a/clang/utils/perf-training/perf-helper.py b/clang/utils/perf-training/perf-helper.py index 88708a92712a..c6a815e65473 100644 --- a/clang/utils/perf-training/perf-helper.py +++ b/clang/utils/perf-training/perf-helper.py @@ -38,7 +38,7 @@ def clean(args): def merge(args): if len(args) != 3: - print('Usage: %s clean \n' % __file__ + + print('Usage: %s merge \n' % __file__ + '\tMerges all profraw files from path into output.') return 1 cmd = [args[0], 'merge', '-o', args[1]] @@ -46,6 +46,16 @@ def merge(args): subprocess.check_call(cmd) return 0 +def merge_fdata(args): + if len(args) != 3: + print('Usage: %s merge-fdata \n' % __file__ + + '\tMerges all fdata files from path into output.') + return 1 + cmd = [args[0], '-o', args[1]] + cmd.extend(findFilesWithExtension(args[2], "fdata")) + subprocess.check_call(cmd) + return 0 + def dtrace(args): parser = argparse.ArgumentParser(prog='perf-helper dtrace', description='dtrace wrapper for order file generation') @@ -395,10 +405,12 @@ def genOrderFile(args): return 0 commands = {'clean' : clean, - 'merge' : merge, + 'merge' : merge, 'dtrace' : dtrace, 'cc1' : cc1, - 'gen-order-file' : genOrderFile} + 'gen-order-file' : genOrderFile, + 'merge-fdata' : merge_fdata, + } def main(): f = commands[sys.argv[1]] From 2502c3afe0beafb90e447ec69d0891930557d494 Mon Sep 17 00:00:00 2001 From: Jean Perier Date: Fri, 23 Sep 2022 10:09:49 +0200 Subject: [PATCH 007/610] [flang] Add TODOs for some FORALL assignments with Pointers and Allocatables Add TODO for whole array allocatable assignment inside FORALL Whole allocatable array assignment inside FORALL are otherwise currently hitting more cryptic asserts. Add TODO in FORALL assignment when a designator appear with a part ref that is an allocatable or pointer component (a(i)%pointer%k). The lowering code does not handle this case well because of the pointer dereference. Differential Revision: https://reviews.llvm.org/D134440 --- flang/lib/Lower/ConvertExpr.cpp | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/flang/lib/Lower/ConvertExpr.cpp b/flang/lib/Lower/ConvertExpr.cpp index 51f77ffa26c5..27503a70dd2e 100644 --- a/flang/lib/Lower/ConvertExpr.cpp +++ b/flang/lib/Lower/ConvertExpr.cpp @@ -3856,6 +3856,9 @@ class ArrayExprLowering { // FIXME: If the lhs is in an explicit iteration space, the assignment may // be to an array of allocatable arrays rather than a single allocatable // array. + if (explicitSpaceIsActive() && lhs.Rank() > 0) + TODO(loc, "assignment to whole allocatable array inside FORALL"); + fir::MutableBoxValue mutableBox = Fortran::lower::createMutableBox(loc, converter, lhs, symMap); if (rhs.Rank() > 0) @@ -7174,7 +7177,9 @@ class ArrayExprLowering { if (components.hasExtendCoorRef()) { auto eleBoxTy = fir::applyPathToType(innerArg.getType(), iters.iterVec()); - assert(eleBoxTy && eleBoxTy.isa()); + if (!eleBoxTy || !eleBoxTy.isa()) + TODO(loc, "assignment in a FORALL involving a designator with a " + "POINTER or ALLOCATABLE component part-ref"); auto arrayOp = builder.create( loc, builder.getRefType(eleBoxTy), innerArg, iters.iterVec(), fir::factory::getTypeParams(loc, builder, load)); @@ -7245,7 +7250,9 @@ class ArrayExprLowering { } if (components.hasExtendCoorRef()) { auto eleBoxTy = fir::applyPathToType(load.getType(), iters.iterVec()); - assert(eleBoxTy && eleBoxTy.isa()); + if (!eleBoxTy || !eleBoxTy.isa()) + TODO(loc, "assignment in a FORALL involving a designator with a " + "POINTER or ALLOCATABLE component part-ref"); auto access = builder.create( loc, builder.getRefType(eleBoxTy), load, iters.iterVec(), fir::factory::getTypeParams(loc, builder, load)); From 7e1a87387209252dec5902925a232467db951db6 Mon Sep 17 00:00:00 2001 From: Daniel Kiss Date: Fri, 23 Sep 2022 10:25:01 +0200 Subject: [PATCH 008/610] [Arm][AArch64] Make getArchFeatures to use TargetParser.def Prefixing the the SubArch with plus sign makes the ArchFeature name. Reviewed By: DavidSpickett Differential Revision: https://reviews.llvm.org/D134349 --- clang/test/Driver/arch.c | 2 +- clang/test/Driver/arm-cortex-cpus-1.c | 10 +++--- clang/test/Driver/arm-cortex-cpus-2.c | 10 +++--- clang/test/Driver/arm-features.c | 8 ++--- clang/test/Driver/arm-target-as-march-mcpu.s | 2 +- .../llvm/Support/AArch64TargetParser.def | 4 +-- .../llvm/Support/AArch64TargetParser.h | 4 +-- llvm/include/llvm/Support/ARMTargetParser.def | 2 +- llvm/include/llvm/Support/ARMTargetParser.h | 11 ++++-- llvm/lib/Support/AArch64TargetParser.cpp | 35 +++---------------- llvm/unittests/Support/TargetParserTest.cpp | 4 +-- 11 files changed, 37 insertions(+), 55 deletions(-) diff --git a/clang/test/Driver/arch.c b/clang/test/Driver/arch.c index f113c1dfa5c2..09afc6a6455b 100644 --- a/clang/test/Driver/arch.c +++ b/clang/test/Driver/arch.c @@ -2,4 +2,4 @@ // RUN: %clang -target armv8a-unknown-linux-gnueabi -S -emit-llvm %s -o - | FileCheck %s --check-prefix=V8 // V7: target triple = "armv7-unknown-linux-gnueabi" -// V8: target triple = "armv8-unknown-linux-gnueabi" +// V8: target triple = "armv8a-unknown-linux-gnueabi" diff --git a/clang/test/Driver/arm-cortex-cpus-1.c b/clang/test/Driver/arm-cortex-cpus-1.c index 7b6c203b53b8..bfdf4d151579 100644 --- a/clang/test/Driver/arm-cortex-cpus-1.c +++ b/clang/test/Driver/arm-cortex-cpus-1.c @@ -148,7 +148,7 @@ // RUN: %clang -target armv8a -mlittle-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V8A %s // RUN: %clang -target arm -march=armv8a -mlittle-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V8A %s // RUN: %clang -target arm -march=armv8-a -mlittle-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V8A %s -// CHECK-V8A: "-cc1"{{.*}} "-triple" "armv8-{{.*}}" "-target-cpu" "generic" +// CHECK-V8A: "-cc1"{{.*}} "-triple" "armv8a-{{.*}}" "-target-cpu" "generic" // RUN: %clang -target armv8r-linux-gnueabi -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V8R %s // RUN: %clang -target arm -march=armv8r -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V8R %s @@ -181,7 +181,7 @@ // RUN: %clang -mcpu=generic -target armv8a -mlittle-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V8A-GENERIC %s // RUN: %clang -mcpu=generic -target arm -march=armv8a -mlittle-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V8A-GENERIC %s // RUN: %clang -mcpu=generic -target arm -march=armv8-a -mlittle-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V8A-GENERIC %s -// CHECK-V8A-GENERIC: "-cc1"{{.*}} "-triple" "armv8-{{.*}}" "-target-cpu" "generic" +// CHECK-V8A-GENERIC: "-cc1"{{.*}} "-triple" "armv8a-{{.*}}" "-target-cpu" "generic" // RUN: %clang -target armebv8 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-V8A %s // RUN: %clang -target armeb -march=armebv8 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-V8A %s @@ -193,7 +193,7 @@ // RUN: %clang -target armv8a -mbig-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-V8A %s // RUN: %clang -target arm -march=armebv8a -mbig-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-V8A %s // RUN: %clang -target arm -march=armebv8-a -mbig-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-V8A %s -// CHECK-BE-V8A: "-cc1"{{.*}} "-triple" "armebv8-{{.*}}" "-target-cpu" "generic" +// CHECK-BE-V8A: "-cc1"{{.*}} "-triple" "armebv8a-{{.*}}" "-target-cpu" "generic" // RUN: %clang -target armv8 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V8A-THUMB %s // RUN: %clang -target arm -march=armv8 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V8A-THUMB %s @@ -203,7 +203,7 @@ // RUN: %clang -target arm -march=armv8 -mlittle-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V8A-THUMB %s // RUN: %clang -target armv8a -mlittle-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V8A-THUMB %s // RUN: %clang -target arm -march=armv8a -mlittle-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V8A-THUMB %s -// CHECK-V8A-THUMB: "-cc1"{{.*}} "-triple" "thumbv8-{{.*}}" "-target-cpu" "generic" +// CHECK-V8A-THUMB: "-cc1"{{.*}} "-triple" "thumbv8a-{{.*}}" "-target-cpu" "generic" // RUN: %clang -target armebv8 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-V8A-THUMB %s // RUN: %clang -target armeb -march=armebv8 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-V8A-THUMB %s @@ -213,7 +213,7 @@ // RUN: %clang -target arm -march=armebv8 -mbig-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-V8A-THUMB %s // RUN: %clang -target armv8a -mbig-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-V8A-THUMB %s // RUN: %clang -target arm -march=armebv8a -mbig-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-V8A-THUMB %s -// CHECK-BE-V8A-THUMB: "-cc1"{{.*}} "-triple" "thumbebv8-{{.*}}" "-target-cpu" "generic" +// CHECK-BE-V8A-THUMB: "-cc1"{{.*}} "-triple" "thumbebv8a-{{.*}}" "-target-cpu" "generic" // RUN: %clang -target arm -march=armv8.1a -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V81A %s // RUN: %clang -target armv8.1a -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V81A %s diff --git a/clang/test/Driver/arm-cortex-cpus-2.c b/clang/test/Driver/arm-cortex-cpus-2.c index 5441e4da2462..8241b521fcb8 100644 --- a/clang/test/Driver/arm-cortex-cpus-2.c +++ b/clang/test/Driver/arm-cortex-cpus-2.c @@ -331,7 +331,7 @@ // // RUN: %clang -target arm -mcpu=exynos-m3 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV8A %s // RUN: %clang -target arm -mcpu=exynos-m3 -mlittle-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV8A %s -// CHECK-CPUV8A: "-cc1"{{.*}} "-triple" "armv8- +// CHECK-CPUV8A: "-cc1"{{.*}} "-triple" "armv8a- // RUN: %clang -target arm -mcpu=cortex-a55 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV82A %s // RUN: %clang -target arm -mcpu=cortex-a75 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV82A %s @@ -365,7 +365,7 @@ // // RUN: %clang -target armeb -mcpu=exynos-m3 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV8A %s // RUN: %clang -target arm -mcpu=exynos-m3 -mbig-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV8A %s -// CHECK-BE-CPUV8A: "-cc1"{{.*}} "-triple" "armebv8- +// CHECK-BE-CPUV8A: "-cc1"{{.*}} "-triple" "armebv8a- // RUN: %clang -target armeb -mcpu=cortex-a55 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV82A %s // RUN: %clang -target armeb -mcpu=cortex-a75 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV82A %s @@ -402,7 +402,7 @@ // // RUN: %clang -target arm -mcpu=exynos-m3 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV8A-THUMB %s // RUN: %clang -target arm -mcpu=exynos-m3 -mlittle-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV8A-THUMB %s -// CHECK-CPUV8A-THUMB: "-cc1"{{.*}} "-triple" "thumbv8- +// CHECK-CPUV8A-THUMB: "-cc1"{{.*}} "-triple" "thumbv8a- // RUN: %clang -target arm -mcpu=cortex-a55 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV82A-THUMB %s // RUN: %clang -target arm -mcpu=cortex-a75 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV82A-THUMB %s @@ -436,7 +436,7 @@ // // RUN: %clang -target armeb -mcpu=exynos-m3 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV8A-THUMB %s // RUN: %clang -target arm -mcpu=exynos-m3 -mbig-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV8A-THUMB %s -// CHECK-BE-CPUV8A-THUMB: "-cc1"{{.*}} "-triple" "thumbebv8- +// CHECK-BE-CPUV8A-THUMB: "-cc1"{{.*}} "-triple" "thumbebv8a- // RUN: %clang -target armeb -mcpu=cortex-a55 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV82A-THUMB %s // RUN: %clang -target armeb -mcpu=cortex-a75 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV82A-THUMB %s @@ -458,7 +458,7 @@ // RUN: %clang -target armv8a-arm-none-eabi -mcpu=cortex-a73 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CORTEX-A73 %s // RUN: %clang -target armv8a-arm-none-eabi -mcpu=cortex-a73 -mfpu=crypto-neon-fp-armv8 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CORTEX-A73-MFPU %s // RUN: %clang -target armv8a-arm-none-eabi -mcpu=cortex-a73 -mfloat-abi=soft -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CORTEX-A73-SOFT %s -// CHECK-CORTEX-A73: "-cc1"{{.*}} "-triple" "armv8-{{.*}} "-target-cpu" "cortex-a73" +// CHECK-CORTEX-A73: "-cc1"{{.*}} "-triple" "armv8a-{{.*}} "-target-cpu" "cortex-a73" // CHECK-CORTEX-A73-MFPU: "-cc1"{{.*}} "-target-feature" "+fp-armv8" // CHECK-CORTEX-A73-MFPU: "-target-feature" "+sha2" // CHECK-CORTEX-A73-MFPU: "-target-feature" "+aes" diff --git a/clang/test/Driver/arm-features.c b/clang/test/Driver/arm-features.c index c07a36ca57da..e043244f18a6 100644 --- a/clang/test/Driver/arm-features.c +++ b/clang/test/Driver/arm-features.c @@ -1,19 +1,19 @@ // RUN: %clang -target arm-none-none-eabi -mcpu=generic+crc -march=armv8a -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CRC %s // RUN: %clang -target arm-none-none-eabi -mcpu=generic -march=armv8a+crc -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CRC %s -// CHECK-CRC: "-cc1"{{.*}} "-triple" "armv8-{{.*}} "-target-cpu" "generic"{{.*}} "-target-feature" "+crc" +// CHECK-CRC: "-cc1"{{.*}} "-triple" "armv8a-{{.*}} "-target-cpu" "generic"{{.*}} "-target-feature" "+crc" // RUN: %clang -target arm-none-none-eabi -mcpu=generic+crypto -march=armv8a -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CRYPTO %s // RUN: %clang -target arm-none-none-eabi -mcpu=generic -march=armv8a+crypto -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CRYPTO %s -// CHECK-CRYPTO: "-cc1"{{.*}} "-triple" "armv8-{{.*}} "-target-cpu" "generic"{{.*}} "-target-feature" "+sha2" "-target-feature" "+aes" +// CHECK-CRYPTO: "-cc1"{{.*}} "-triple" "armv8a-{{.*}} "-target-cpu" "generic"{{.*}} "-target-feature" "+sha2" "-target-feature" "+aes" // RUN: %clang -target arm-none-none-eabi -mcpu=generic+dsp -march=armv8m.main -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-DSP %s // RUN: %clang -target arm-none-none-eabi -mcpu=generic -march=armv8m.main+dsp -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-DSP %s // CHECK-DSP: "-cc1"{{.*}} "-triple" "thumbv8m.main-{{.*}} "-target-cpu" "generic"{{.*}} "-target-feature" "+dsp" // RUN: %clang -target arm-none-none-eabi -mcpu=generic+nocrc -march=armv8a -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-NOCRC %s // RUN: %clang -target arm-none-none-eabi -mcpu=generic -march=armv8a+nocrc -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-NOCRC %s -// CHECK-NOCRC: "-cc1"{{.*}} "-triple" "armv8-{{.*}} "-target-cpu" "generic"{{.*}} "-target-feature" "-crc" +// CHECK-NOCRC: "-cc1"{{.*}} "-triple" "armv8a-{{.*}} "-target-cpu" "generic"{{.*}} "-target-feature" "-crc" // RUN: %clang -target arm-none-none-eabi -mcpu=generic+nocrypto -march=armv8a -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-NOCRYPTO %s // RUN: %clang -target arm-none-none-eabi -mcpu=generic -march=armv8a+nocrypto -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-NOCRYPTO %s -// CHECK-NOCRYPTO: "-cc1"{{.*}} "-triple" "armv8-{{.*}} "-target-cpu" "generic"{{.*}} "-target-feature" "-sha2" "-target-feature" "-aes" +// CHECK-NOCRYPTO: "-cc1"{{.*}} "-triple" "armv8a-{{.*}} "-target-cpu" "generic"{{.*}} "-target-feature" "-sha2" "-target-feature" "-aes" // RUN: %clang -target arm-none-none-eabi -mcpu=generic+nodsp -march=armv8m.main -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-NODSP %s // RUN: %clang -target arm-none-none-eabi -mcpu=generic -march=armv8m.main+nodsp -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-NODSP %s // CHECK-NODSP: "-cc1"{{.*}} "-triple" "thumbv8m.main-{{.*}} "-target-cpu" "generic"{{.*}} "-target-feature" "-dsp" diff --git a/clang/test/Driver/arm-target-as-march-mcpu.s b/clang/test/Driver/arm-target-as-march-mcpu.s index 186b3a497e0b..2e8d7f45eb35 100644 --- a/clang/test/Driver/arm-target-as-march-mcpu.s +++ b/clang/test/Driver/arm-target-as-march-mcpu.s @@ -99,6 +99,6 @@ // TRIPLE-ARMV4: "-triple" "armv4t-unknown-linux-gnueabi" // TRIPLE-ARMV7: "-triple" "armv7-unknown-linux-gnueabi" -// TRIPLE-ARMV8: "-triple" "armv8-unknown-linux-gnueabi" +// TRIPLE-ARMV8: "-triple" "armv8a-unknown-linux-gnueabi" // CPU-A8: "-target-cpu" "cortex-a8" // EXT-CRC: "-target-feature" "+crc" diff --git a/llvm/include/llvm/Support/AArch64TargetParser.def b/llvm/include/llvm/Support/AArch64TargetParser.def index 72286439e0f8..b281cb2dcb18 100644 --- a/llvm/include/llvm/Support/AArch64TargetParser.def +++ b/llvm/include/llvm/Support/AArch64TargetParser.def @@ -17,7 +17,7 @@ #endif AARCH64_ARCH("invalid", INVALID, "", "", ARMBuildAttrs::CPUArch::v8_A, FK_NONE, AArch64::AEK_NONE) -AARCH64_ARCH("armv8-a", ARMV8A, "8-A", "v8", ARMBuildAttrs::CPUArch::v8_A, +AARCH64_ARCH("armv8-a", ARMV8A, "8-A", "v8a", ARMBuildAttrs::CPUArch::v8_A, FK_CRYPTO_NEON_FP_ARMV8, (AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_SIMD)) AARCH64_ARCH("armv8.1-a", ARMV8_1A, "8.1-A", "v8.1a", @@ -83,7 +83,7 @@ AARCH64_ARCH("armv9.2-a", ARMV9_2A, "9.2-A", "v9.2a", AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_LSE | AArch64::AEK_RDM | AArch64::AEK_RCPC | AArch64::AEK_DOTPROD | AArch64::AEK_SVE2)) -AARCH64_ARCH("armv9.3-a", ARMV9_3A, "9.3-A", "v9.3", +AARCH64_ARCH("armv9.3-a", ARMV9_3A, "9.3-A", "v9.3a", ARMBuildAttrs::CPUArch::v8_A, FK_CRYPTO_NEON_FP_ARMV8, (AArch64::AEK_CRC | AArch64::AEK_FP | AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_LSE | diff --git a/llvm/include/llvm/Support/AArch64TargetParser.h b/llvm/include/llvm/Support/AArch64TargetParser.h index 81935c2a8cd2..f1f985016ed8 100644 --- a/llvm/include/llvm/Support/AArch64TargetParser.h +++ b/llvm/include/llvm/Support/AArch64TargetParser.h @@ -86,8 +86,8 @@ const ARM::ArchNames AArch64ARCHNames[] = { sizeof(NAME) - 1, \ CPU_ATTR, \ sizeof(CPU_ATTR) - 1, \ - SUB_ARCH, \ - sizeof(SUB_ARCH) - 1, \ + "+" SUB_ARCH, \ + sizeof(SUB_ARCH), \ ARM::FPUKind::ARCH_FPU, \ ARCH_BASE_EXT, \ AArch64::ArchKind::ID, \ diff --git a/llvm/include/llvm/Support/ARMTargetParser.def b/llvm/include/llvm/Support/ARMTargetParser.def index ad498047b088..dc7b84f14108 100644 --- a/llvm/include/llvm/Support/ARMTargetParser.def +++ b/llvm/include/llvm/Support/ARMTargetParser.def @@ -78,7 +78,7 @@ ARM_ARCH("armv7-m", ARMV7M, "7-M", "v7m", ARMBuildAttrs::CPUArch::v7, FK_NONE, ARM::AEK_HWDIVTHUMB) ARM_ARCH("armv7e-m", ARMV7EM, "7E-M", "v7em", ARMBuildAttrs::CPUArch::v7E_M, FK_NONE, (ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP)) -ARM_ARCH("armv8-a", ARMV8A, "8-A", "v8", ARMBuildAttrs::CPUArch::v8_A, +ARM_ARCH("armv8-a", ARMV8A, "8-A", "v8a", ARMBuildAttrs::CPUArch::v8_A, FK_CRYPTO_NEON_FP_ARMV8, (ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_CRC)) diff --git a/llvm/include/llvm/Support/ARMTargetParser.h b/llvm/include/llvm/Support/ARMTargetParser.h index 1ada6daaad3b..06cb8eabc993 100644 --- a/llvm/include/llvm/Support/ARMTargetParser.h +++ b/llvm/include/llvm/Support/ARMTargetParser.h @@ -216,7 +216,14 @@ template struct ArchNames { StringRef getCPUAttr() const { return StringRef(CPUAttrCStr, CPUAttrLength); } // Sub-Arch name. - StringRef getSubArch() const { return StringRef(SubArchCStr, SubArchLength); } + StringRef getSubArch() const { + return getArchFeature().substr(1, SubArchLength); + } + + // Arch Feature name. + StringRef getArchFeature() const { + return StringRef(SubArchCStr, SubArchLength); + } }; static const ArchNames ARCHNames[] = { @@ -224,7 +231,7 @@ static const ArchNames ARCHNames[] = { ARCH_BASE_EXT) \ {NAME, sizeof(NAME) - 1, \ CPU_ATTR, sizeof(CPU_ATTR) - 1, \ - SUB_ARCH, sizeof(SUB_ARCH) - 1, \ + "+" SUB_ARCH, sizeof(SUB_ARCH), \ ARCH_FPU, ARCH_BASE_EXT, \ ArchKind::ID, ARCH_ATTR}, #include "llvm/Support/ARMTargetParser.def" diff --git a/llvm/lib/Support/AArch64TargetParser.cpp b/llvm/lib/Support/AArch64TargetParser.cpp index e2579bf53260..b0d5c205864f 100644 --- a/llvm/lib/Support/AArch64TargetParser.cpp +++ b/llvm/lib/Support/AArch64TargetParser.cpp @@ -78,36 +78,11 @@ bool AArch64::getExtensionFeatures(uint64_t Extensions, bool AArch64::getArchFeatures(AArch64::ArchKind AK, std::vector &Features) { - if (AK == ArchKind::ARMV8A) - Features.push_back("+v8a"); - if (AK == ArchKind::ARMV8_1A) - Features.push_back("+v8.1a"); - if (AK == ArchKind::ARMV8_2A) - Features.push_back("+v8.2a"); - if (AK == ArchKind::ARMV8_3A) - Features.push_back("+v8.3a"); - if (AK == ArchKind::ARMV8_4A) - Features.push_back("+v8.4a"); - if (AK == ArchKind::ARMV8_5A) - Features.push_back("+v8.5a"); - if (AK == AArch64::ArchKind::ARMV8_6A) - Features.push_back("+v8.6a"); - if (AK == AArch64::ArchKind::ARMV8_7A) - Features.push_back("+v8.7a"); - if (AK == AArch64::ArchKind::ARMV8_8A) - Features.push_back("+v8.8a"); - if (AK == AArch64::ArchKind::ARMV9A) - Features.push_back("+v9a"); - if (AK == AArch64::ArchKind::ARMV9_1A) - Features.push_back("+v9.1a"); - if (AK == AArch64::ArchKind::ARMV9_2A) - Features.push_back("+v9.2a"); - if (AK == AArch64::ArchKind::ARMV9_3A) - Features.push_back("+v9.3a"); - if(AK == AArch64::ArchKind::ARMV8R) - Features.push_back("+v8r"); - - return AK != ArchKind::INVALID; + if (AK == ArchKind::INVALID) + return false; + Features.push_back( + AArch64ARCHNames[static_cast(AK)].getArchFeature()); + return true; } StringRef AArch64::getArchName(AArch64::ArchKind AK) { diff --git a/llvm/unittests/Support/TargetParserTest.cpp b/llvm/unittests/Support/TargetParserTest.cpp index eaa4f0679681..46533b95236e 100644 --- a/llvm/unittests/Support/TargetParserTest.cpp +++ b/llvm/unittests/Support/TargetParserTest.cpp @@ -483,7 +483,7 @@ TEST(TargetParserTest, testARMArch) { testARMArch("armv7e-m", "cortex-m4", "v7em", ARMBuildAttrs::CPUArch::v7E_M)); EXPECT_TRUE( - testARMArch("armv8-a", "generic", "v8", + testARMArch("armv8-a", "generic", "v8a", ARMBuildAttrs::CPUArch::v8_A)); EXPECT_TRUE( testARMArch("armv8.1-a", "generic", "v8.1a", @@ -1308,7 +1308,7 @@ bool testAArch64Arch(StringRef Arch, StringRef DefaultCPU, StringRef SubArch, } TEST(TargetParserTest, testAArch64Arch) { - EXPECT_TRUE(testAArch64Arch("armv8-a", "cortex-a53", "v8", + EXPECT_TRUE(testAArch64Arch("armv8-a", "cortex-a53", "v8a", ARMBuildAttrs::CPUArch::v8_A)); EXPECT_TRUE(testAArch64Arch("armv8.1-a", "generic", "v8.1a", ARMBuildAttrs::CPUArch::v8_A)); From 14947cc4cd1a2a57a4d2728e8bab0daa60023440 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Fri, 23 Sep 2022 10:25:27 +0200 Subject: [PATCH 009/610] [IR] Handle assume intrinsics in hasClobberingOperandBundle() Operand bundles on assumes do not read or write -- we correctly modelled the read side of this, but not the write side. In practice this did not matter because of how the method is used, but this will become relevant for a future patch. --- llvm/include/llvm/IR/InstrTypes.h | 16 +--------------- llvm/lib/IR/Instructions.cpp | 7 +++++++ 2 files changed, 8 insertions(+), 15 deletions(-) diff --git a/llvm/include/llvm/IR/InstrTypes.h b/llvm/include/llvm/IR/InstrTypes.h index 67d4a8c5b956..dc46c8a43c8b 100644 --- a/llvm/include/llvm/IR/InstrTypes.h +++ b/llvm/include/llvm/IR/InstrTypes.h @@ -2075,21 +2075,7 @@ class CallBase : public Instruction { /// Return true if this operand bundle user has operand bundles that /// may write to the heap. - bool hasClobberingOperandBundles() const { - for (const auto &BOI : bundle_op_infos()) { - if (BOI.Tag->second == LLVMContext::OB_deopt || - BOI.Tag->second == LLVMContext::OB_funclet || - BOI.Tag->second == LLVMContext::OB_ptrauth || - BOI.Tag->second == LLVMContext::OB_kcfi) - continue; - - // This instruction has an operand bundle that is not known to us. - // Assume the worst. - return true; - } - - return false; - } + bool hasClobberingOperandBundles() const; /// Return true if the bundle operand at index \p OpIdx has the /// attribute \p A. diff --git a/llvm/lib/IR/Instructions.cpp b/llvm/lib/IR/Instructions.cpp index 861a0628bb18..f3bcd5322f6a 100644 --- a/llvm/lib/IR/Instructions.cpp +++ b/llvm/lib/IR/Instructions.cpp @@ -511,6 +511,13 @@ bool CallBase::hasReadingOperandBundles() const { getIntrinsicID() != Intrinsic::assume; } +bool CallBase::hasClobberingOperandBundles() const { + return hasOperandBundlesOtherThan( + {LLVMContext::OB_deopt, LLVMContext::OB_funclet, + LLVMContext::OB_ptrauth, LLVMContext::OB_kcfi}) && + getIntrinsicID() != Intrinsic::assume; +} + //===----------------------------------------------------------------------===// // CallInst Implementation //===----------------------------------------------------------------------===// From 8e44f13c6d294e6b4864441b22045b507782540c Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Fri, 23 Sep 2022 10:30:52 +0200 Subject: [PATCH 010/610] [MemorySSA] Convert tests to use opaque pointers (NFC) --- llvm/test/Analysis/MemorySSA/assume.ll | 6 +- .../test/Analysis/MemorySSA/atomic-clobber.ll | 80 ++--- .../test/Analysis/MemorySSA/basicaa-memcpy.ll | 12 +- llvm/test/Analysis/MemorySSA/call-bitcast.ll | 9 +- .../Analysis/MemorySSA/constant-memory.ll | 26 +- llvm/test/Analysis/MemorySSA/cyclicphi.ll | 103 +++--- llvm/test/Analysis/MemorySSA/debugvalue.ll | 2 +- llvm/test/Analysis/MemorySSA/debugvalue2.ll | 2 +- .../Analysis/MemorySSA/forward-unreachable.ll | 4 +- .../Analysis/MemorySSA/function-clobber.ll | 6 +- .../Analysis/MemorySSA/function-mem-attrs.ll | 18 +- llvm/test/Analysis/MemorySSA/invalidate.ll | 22 +- .../Analysis/MemorySSA/invariant-groups.ll | 244 +++++++------- .../Analysis/MemorySSA/lifetime-simple.ll | 30 +- .../test/Analysis/MemorySSA/load-invariant.ll | 8 +- .../MemorySSA/loop-rotate-disablebasicaa.ll | 2 +- .../MemorySSA/loop-rotate-inv-template.ll | 8 +- .../MemorySSA/loop-rotate-simplified-clone.ll | 6 +- .../MemorySSA/loop-rotate-valuemap.ll | 4 +- .../loop_rotate_remove_trivial_phis.ll | 12 +- .../Analysis/MemorySSA/many-dom-backedge.ll | 18 +- llvm/test/Analysis/MemorySSA/many-doms.ll | 16 +- llvm/test/Analysis/MemorySSA/multi-edges.ll | 6 +- .../MemorySSA/multiple-backedges-hal.ll | 10 +- .../Analysis/MemorySSA/multiple-locations.ll | 8 +- .../Analysis/MemorySSA/no-disconnected.ll | 26 +- .../Analysis/MemorySSA/noalias-scope-decl.ll | 6 +- .../test/Analysis/MemorySSA/nondeterminism.ll | 10 +- llvm/test/Analysis/MemorySSA/optimize-use.ll | 46 ++- .../Analysis/MemorySSA/phi-translation.ll | 312 +++++++++--------- llvm/test/Analysis/MemorySSA/pr28880.ll | 16 +- llvm/test/Analysis/MemorySSA/pr36883.ll | 16 +- llvm/test/Analysis/MemorySSA/pr39197.ll | 28 +- llvm/test/Analysis/MemorySSA/pr40037.ll | 2 +- llvm/test/Analysis/MemorySSA/pr40038.ll | 20 +- llvm/test/Analysis/MemorySSA/pr40509.ll | 14 +- llvm/test/Analysis/MemorySSA/pr40749.ll | 14 +- llvm/test/Analysis/MemorySSA/pr40749_2.ll | 6 +- llvm/test/Analysis/MemorySSA/pr40754.ll | 8 +- llvm/test/Analysis/MemorySSA/pr41254.ll | 4 +- llvm/test/Analysis/MemorySSA/pr41640.ll | 10 +- llvm/test/Analysis/MemorySSA/pr41853.ll | 2 +- llvm/test/Analysis/MemorySSA/pr42294.ll | 12 +- llvm/test/Analysis/MemorySSA/pr42940.ll | 28 +- llvm/test/Analysis/MemorySSA/pr43044.ll | 8 +- llvm/test/Analysis/MemorySSA/pr43317.ll | 6 +- llvm/test/Analysis/MemorySSA/pr43320.ll | 4 +- llvm/test/Analysis/MemorySSA/pr43426.ll | 4 +- llvm/test/Analysis/MemorySSA/pr43427.ll | 14 +- llvm/test/Analysis/MemorySSA/pr43438.ll | 16 +- llvm/test/Analysis/MemorySSA/pr43493.ll | 2 +- llvm/test/Analysis/MemorySSA/pr43540.ll | 8 +- llvm/test/Analysis/MemorySSA/pr43541.ll | 4 +- llvm/test/Analysis/MemorySSA/pr43569.ll | 18 +- llvm/test/Analysis/MemorySSA/pr43641.ll | 2 +- llvm/test/Analysis/MemorySSA/pr44027.ll | 10 +- llvm/test/Analysis/MemorySSA/pr44029.ll | 14 +- llvm/test/Analysis/MemorySSA/pr45927.ll | 26 +- llvm/test/Analysis/MemorySSA/pr45976.ll | 6 +- llvm/test/Analysis/MemorySSA/pr46574.ll | 10 +- llvm/test/Analysis/MemorySSA/pr49859.ll | 64 ++-- .../Analysis/MemorySSA/print-dot-cfg-mssa.ll | 54 ++- llvm/test/Analysis/MemorySSA/print-walker.ll | 34 +- llvm/test/Analysis/MemorySSA/ptr-const-mem.ll | 10 +- .../MemorySSA/reduce_clobber_limit.ll | 6 +- llvm/test/Analysis/MemorySSA/renamephis.ll | 10 +- llvm/test/Analysis/MemorySSA/scalable-vec.ll | 15 +- .../MemorySSA/update-remove-dead-blocks.ll | 12 +- llvm/test/Analysis/MemorySSA/update_unroll.ll | 2 +- .../Analysis/MemorySSA/volatile-clobber.ll | 68 ++-- 70 files changed, 820 insertions(+), 849 deletions(-) diff --git a/llvm/test/Analysis/MemorySSA/assume.ll b/llvm/test/Analysis/MemorySSA/assume.ll index 543205ebff77..941c1863f7fd 100644 --- a/llvm/test/Analysis/MemorySSA/assume.ll +++ b/llvm/test/Analysis/MemorySSA/assume.ll @@ -4,15 +4,15 @@ declare void @llvm.assume(i1) -define i32 @foo(i32* %a, i32* %b, i1 %c) { +define i32 @foo(ptr %a, ptr %b, i1 %c) { ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i32 4 - store i32 4, i32* %a, align 4 + store i32 4, ptr %a, align 4 ; CHECK-NOT: MemoryDef ; CHECK: call void @llvm.assume call void @llvm.assume(i1 %c) ; CHECK: MemoryUse(1) ; CHECK-NEXT: %1 = load i32 - %1 = load i32, i32* %a, align 4 + %1 = load i32, ptr %a, align 4 ret i32 %1 } diff --git a/llvm/test/Analysis/MemorySSA/atomic-clobber.ll b/llvm/test/Analysis/MemorySSA/atomic-clobber.ll index ea765915280c..326ec8b15283 100644 --- a/llvm/test/Analysis/MemorySSA/atomic-clobber.ll +++ b/llvm/test/Analysis/MemorySSA/atomic-clobber.ll @@ -3,96 +3,96 @@ ; Ensures that atomic loads count as MemoryDefs ; CHECK-LABEL: define i32 @foo -define i32 @foo(i32* %a, i32* %b) { +define i32 @foo(ptr %a, ptr %b) { ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i32 4 - store i32 4, i32* %a, align 4 + store i32 4, ptr %a, align 4 ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: %1 = load atomic i32 - %1 = load atomic i32, i32* %b acquire, align 4 + %1 = load atomic i32, ptr %b acquire, align 4 ; CHECK: MemoryUse(2) ; CHECK-NEXT: %2 = load i32 - %2 = load i32, i32* %a, align 4 + %2 = load i32, ptr %a, align 4 %3 = add i32 %1, %2 ret i32 %3 } ; CHECK-LABEL: define void @bar -define void @bar(i32* %a) { +define void @bar(ptr %a) { ; CHECK: MemoryUse(liveOnEntry) -; CHECK-NEXT: load atomic i32, i32* %a unordered, align 4 - load atomic i32, i32* %a unordered, align 4 +; CHECK-NEXT: load atomic i32, ptr %a unordered, align 4 + load atomic i32, ptr %a unordered, align 4 ; CHECK: 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: load atomic i32, i32* %a monotonic, align 4 - load atomic i32, i32* %a monotonic, align 4 +; CHECK-NEXT: load atomic i32, ptr %a monotonic, align 4 + load atomic i32, ptr %a monotonic, align 4 ; CHECK: 2 = MemoryDef(1) -; CHECK-NEXT: load atomic i32, i32* %a acquire, align 4 - load atomic i32, i32* %a acquire, align 4 +; CHECK-NEXT: load atomic i32, ptr %a acquire, align 4 + load atomic i32, ptr %a acquire, align 4 ; CHECK: 3 = MemoryDef(2) -; CHECK-NEXT: load atomic i32, i32* %a seq_cst, align 4 - load atomic i32, i32* %a seq_cst, align 4 +; CHECK-NEXT: load atomic i32, ptr %a seq_cst, align 4 + load atomic i32, ptr %a seq_cst, align 4 ret void } ; CHECK-LABEL: define void @baz -define void @baz(i32* %a) { +define void @baz(ptr %a) { ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: %1 = load atomic i32 - %1 = load atomic i32, i32* %a acquire, align 4 + %1 = load atomic i32, ptr %a acquire, align 4 ; CHECK: MemoryUse(1) -; CHECK-NEXT: %2 = load atomic i32, i32* %a unordered, align 4 - %2 = load atomic i32, i32* %a unordered, align 4 +; CHECK-NEXT: %2 = load atomic i32, ptr %a unordered, align 4 + %2 = load atomic i32, ptr %a unordered, align 4 ; CHECK: 2 = MemoryDef(1) -; CHECK-NEXT: %3 = load atomic i32, i32* %a monotonic, align 4 - %3 = load atomic i32, i32* %a monotonic, align 4 +; CHECK-NEXT: %3 = load atomic i32, ptr %a monotonic, align 4 + %3 = load atomic i32, ptr %a monotonic, align 4 ret void } ; CHECK-LABEL: define void @fences -define void @fences(i32* %a) { +define void @fences(ptr %a) { ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: fence acquire fence acquire ; CHECK: MemoryUse(1) -; CHECK-NEXT: %1 = load i32, i32* %a - %1 = load i32, i32* %a +; CHECK-NEXT: %1 = load i32, ptr %a + %1 = load i32, ptr %a ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: fence release fence release ; CHECK: MemoryUse(2) -; CHECK-NEXT: %2 = load i32, i32* %a - %2 = load i32, i32* %a +; CHECK-NEXT: %2 = load i32, ptr %a + %2 = load i32, ptr %a ; CHECK: 3 = MemoryDef(2) ; CHECK-NEXT: fence acq_rel fence acq_rel ; CHECK: MemoryUse(3) -; CHECK-NEXT: %3 = load i32, i32* %a - %3 = load i32, i32* %a +; CHECK-NEXT: %3 = load i32, ptr %a + %3 = load i32, ptr %a ; CHECK: 4 = MemoryDef(3) ; CHECK-NEXT: fence seq_cst fence seq_cst ; CHECK: MemoryUse(4) -; CHECK-NEXT: %4 = load i32, i32* %a - %4 = load i32, i32* %a +; CHECK-NEXT: %4 = load i32, ptr %a + %4 = load i32, ptr %a ret void } ; CHECK-LABEL: define void @seq_cst_clobber -define void @seq_cst_clobber(i32* noalias %a, i32* noalias %b) { +define void @seq_cst_clobber(ptr noalias %a, ptr noalias %b) { ; CHECK: 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: %1 = load atomic i32, i32* %a monotonic, align 4 - load atomic i32, i32* %a monotonic, align 4 +; CHECK-NEXT: %1 = load atomic i32, ptr %a monotonic, align 4 + load atomic i32, ptr %a monotonic, align 4 ; CHECK: 2 = MemoryDef(1) -; CHECK-NEXT: %2 = load atomic i32, i32* %a seq_cst, align 4 - load atomic i32, i32* %a seq_cst, align 4 +; CHECK-NEXT: %2 = load atomic i32, ptr %a seq_cst, align 4 + load atomic i32, ptr %a seq_cst, align 4 ; CHECK: 3 = MemoryDef(2) -; CHECK-NEXT: load atomic i32, i32* %a monotonic, align 4 - load atomic i32, i32* %a monotonic, align 4 +; CHECK-NEXT: load atomic i32, ptr %a monotonic, align 4 + load atomic i32, ptr %a monotonic, align 4 ret void } @@ -106,13 +106,13 @@ define void @seq_cst_clobber(i32* noalias %a, i32* noalias %b) { ; If AA gets more aggressive, we can find another way. ; ; CHECK-LABEL: define void @check_aa_is_sane -define void @check_aa_is_sane(i32* noalias %a, i32* noalias %b) { +define void @check_aa_is_sane(ptr noalias %a, ptr noalias %b) { ; CHECK: 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: cmpxchg i32* %a, i32 0, i32 1 acquire acquire - cmpxchg i32* %a, i32 0, i32 1 acquire acquire +; CHECK-NEXT: cmpxchg ptr %a, i32 0, i32 1 acquire acquire + cmpxchg ptr %a, i32 0, i32 1 acquire acquire ; CHECK: MemoryUse(1) -; CHECK-NEXT: load i32, i32* %b, align 4 - load i32, i32* %b, align 4 +; CHECK-NEXT: load i32, ptr %b, align 4 + load i32, ptr %b, align 4 ret void } diff --git a/llvm/test/Analysis/MemorySSA/basicaa-memcpy.ll b/llvm/test/Analysis/MemorySSA/basicaa-memcpy.ll index 69a3b3229ce4..d548c9be92d2 100644 --- a/llvm/test/Analysis/MemorySSA/basicaa-memcpy.ll +++ b/llvm/test/Analysis/MemorySSA/basicaa-memcpy.ll @@ -1,16 +1,16 @@ ; RUN: opt -disable-output -passes='print' %s 2>&1 | FileCheck %s -declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind +declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind -define void @source_clobber(i8* %a, i8* %b) { +define void @source_clobber(ptr %a, ptr %b) { ; CHECK-LABEL: @source_clobber( ; CHECK-NEXT: ; 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 128, i1 false) +; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr %a, ptr %b, i64 128, i1 false) ; CHECK-NEXT: ; MemoryUse(1) -; CHECK-NEXT: [[X:%.*]] = load i8, i8* %b +; CHECK-NEXT: [[X:%.*]] = load i8, ptr %b ; CHECK-NEXT: ret void ; - call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 128, i1 false) - %x = load i8, i8* %b + call void @llvm.memcpy.p0.p0.i64(ptr %a, ptr %b, i64 128, i1 false) + %x = load i8, ptr %b ret void } diff --git a/llvm/test/Analysis/MemorySSA/call-bitcast.ll b/llvm/test/Analysis/MemorySSA/call-bitcast.ll index f0d1955b718f..0e946091273c 100644 --- a/llvm/test/Analysis/MemorySSA/call-bitcast.ll +++ b/llvm/test/Analysis/MemorySSA/call-bitcast.ll @@ -1,14 +1,15 @@ ; RUN: opt -aa-pipeline=basic-aa -passes='print,verify' -disable-output < %s 2>&1 | FileCheck %s ; -; Ensures that MemorySSA leverages the ground truth of the function being called when wrapped in a bitcast. +; Ensures that MemorySSA leverages the ground truth of the function being +; called even if the call and function signatures don't match. declare i1 @opaque_true(i1) nounwind readonly -define i1 @foo(i32* %ptr, i1 %cond) { +define i1 @foo(ptr %ptr, i1 %cond) { %cond_wide = zext i1 %cond to i32 ; CHECK: MemoryUse(liveOnEntry) -; CHECK-NEXT: call i32 bitcast - %cond_hidden_wide = call i32 bitcast (i1 (i1)* @opaque_true to i32 (i32)*)(i32 %cond_wide) +; CHECK-NEXT: call i32 @opaque_true(i32 %cond_wide) + %cond_hidden_wide = call i32 @opaque_true(i32 %cond_wide) %cond_hidden = trunc i32 %cond_hidden_wide to i1 ret i1 %cond_hidden } diff --git a/llvm/test/Analysis/MemorySSA/constant-memory.ll b/llvm/test/Analysis/MemorySSA/constant-memory.ll index be4a1ba9ed26..5db4e66da14b 100644 --- a/llvm/test/Analysis/MemorySSA/constant-memory.ll +++ b/llvm/test/Analysis/MemorySSA/constant-memory.ll @@ -11,31 +11,29 @@ define i8 @foo() { ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: call void @clobberAllTheThings() call void @clobberAllTheThings() - %1 = getelementptr [2 x i8], [2 x i8]* @str, i64 0, i64 0 ; CHECK: MemoryUse(liveOnEntry) -; CHECK-NEXT: %2 = load i8 - %2 = load i8, i8* %1, align 1 - %3 = getelementptr [2 x i8], [2 x i8]* @str, i64 0, i64 1 +; CHECK-NEXT: %1 = load i8 + %1 = load i8, ptr @str, align 1 + %2 = getelementptr [2 x i8], ptr @str, i64 0, i64 1 ; CHECK: MemoryUse(liveOnEntry) -; CHECK-NEXT: %4 = load i8 - %4 = load i8, i8* %3, align 1 - %5 = add i8 %2, %4 - ret i8 %5 +; CHECK-NEXT: %3 = load i8 + %3 = load i8, ptr %2, align 1 + %4 = add i8 %1, %3 + ret i8 %4 } define i8 @select(i1 %b) { %1 = alloca i8, align 1 ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i8 0 - store i8 0, i8* %1, align 1 + store i8 0, ptr %1, align 1 ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: call void @clobberAllTheThings() call void @clobberAllTheThings() - %2 = getelementptr [2 x i8], [2 x i8]* @str, i64 0, i64 0 - %3 = select i1 %b, i8* %2, i8* %1 + %2 = select i1 %b, ptr @str, ptr %1 ; CHECK: MemoryUse(2) -; CHECK-NEXT: %4 = load i8 - %4 = load i8, i8* %3, align 1 - ret i8 %4 +; CHECK-NEXT: %3 = load i8 + %3 = load i8, ptr %2, align 1 + ret i8 %3 } diff --git a/llvm/test/Analysis/MemorySSA/cyclicphi.ll b/llvm/test/Analysis/MemorySSA/cyclicphi.ll index f1980bb7302e..8a4ec1753fdc 100644 --- a/llvm/test/Analysis/MemorySSA/cyclicphi.ll +++ b/llvm/test/Analysis/MemorySSA/cyclicphi.ll @@ -3,10 +3,9 @@ %struct.hoge = type { i32, %struct.widget } %struct.widget = type { i64 } -define hidden void @quux(%struct.hoge *%f) align 2 { - %tmp = getelementptr inbounds %struct.hoge, %struct.hoge* %f, i64 0, i32 1, i32 0 - %tmp24 = getelementptr inbounds %struct.hoge, %struct.hoge* %f, i64 0, i32 1 - %tmp25 = bitcast %struct.widget* %tmp24 to i64** +define hidden void @quux(ptr %f) align 2 { + %tmp = getelementptr inbounds %struct.hoge, ptr %f, i64 0, i32 1, i32 0 + %tmp24 = getelementptr inbounds %struct.hoge, ptr %f, i64 0, i32 1 br label %bb26 bb26: ; preds = %bb77, %0 @@ -16,27 +15,26 @@ bb26: ; preds = %bb77, %0 bb68: ; preds = %bb26 ; CHECK: MemoryUse(liveOnEntry) -; CHECK-NEXT: %tmp69 = load i64, i64* null, align 8 - %tmp69 = load i64, i64* null, align 8 +; CHECK-NEXT: %tmp69 = load i64, ptr null, align 8 + %tmp69 = load i64, ptr null, align 8 ; CHECK: 1 = MemoryDef(3) -; CHECK-NEXT: store i64 %tmp69, i64* %tmp, align 8 - store i64 %tmp69, i64* %tmp, align 8 +; CHECK-NEXT: store i64 %tmp69, ptr %tmp, align 8 + store i64 %tmp69, ptr %tmp, align 8 br label %bb77 bb77: ; preds = %bb68, %bb26 ; CHECK: 2 = MemoryPhi({bb26,3},{bb68,1}) ; CHECK: MemoryUse(2) -; CHECK-NEXT: %tmp78 = load i64*, i64** %tmp25, align 8 - %tmp78 = load i64*, i64** %tmp25, align 8 - %tmp79 = getelementptr inbounds i64, i64* %tmp78, i64 undef +; CHECK-NEXT: %tmp78 = load ptr, ptr %tmp24, align 8 + %tmp78 = load ptr, ptr %tmp24, align 8 + %tmp79 = getelementptr inbounds i64, ptr %tmp78, i64 undef br label %bb26 } -define hidden void @quux_no_null_opt(%struct.hoge *%f) align 2 #0 { +define hidden void @quux_no_null_opt(ptr %f) align 2 #0 { ; CHECK-LABEL: quux_no_null_opt( - %tmp = getelementptr inbounds %struct.hoge, %struct.hoge* %f, i64 0, i32 1, i32 0 - %tmp24 = getelementptr inbounds %struct.hoge, %struct.hoge* %f, i64 0, i32 1 - %tmp25 = bitcast %struct.widget* %tmp24 to i64** + %tmp = getelementptr inbounds %struct.hoge, ptr %f, i64 0, i32 1, i32 0 + %tmp24 = getelementptr inbounds %struct.hoge, ptr %f, i64 0, i32 1 br label %bb26 bb26: ; preds = %bb77, %0 @@ -46,27 +44,26 @@ bb26: ; preds = %bb77, %0 bb68: ; preds = %bb26 ; CHECK: MemoryUse(3) -; CHECK-NEXT: %tmp69 = load i64, i64* null, align 8 - %tmp69 = load i64, i64* null, align 8 +; CHECK-NEXT: %tmp69 = load i64, ptr null, align 8 + %tmp69 = load i64, ptr null, align 8 ; CHECK: 1 = MemoryDef(3) -; CHECK-NEXT: store i64 %tmp69, i64* %tmp, align 8 - store i64 %tmp69, i64* %tmp, align 8 +; CHECK-NEXT: store i64 %tmp69, ptr %tmp, align 8 + store i64 %tmp69, ptr %tmp, align 8 br label %bb77 bb77: ; preds = %bb68, %bb26 ; CHECK: 2 = MemoryPhi({bb26,3},{bb68,1}) ; CHECK: MemoryUse(2) -; CHECK-NEXT: %tmp78 = load i64*, i64** %tmp25, align 8 - %tmp78 = load i64*, i64** %tmp25, align 8 - %tmp79 = getelementptr inbounds i64, i64* %tmp78, i64 undef +; CHECK-NEXT: %tmp78 = load ptr, ptr %tmp24, align 8 + %tmp78 = load ptr, ptr %tmp24, align 8 + %tmp79 = getelementptr inbounds i64, ptr %tmp78, i64 undef br label %bb26 } ; CHECK-LABEL: define void @quux_skip -define void @quux_skip(%struct.hoge* noalias %f, i64* noalias %g) align 2 { - %tmp = getelementptr inbounds %struct.hoge, %struct.hoge* %f, i64 0, i32 1, i32 0 - %tmp24 = getelementptr inbounds %struct.hoge, %struct.hoge* %f, i64 0, i32 1 - %tmp25 = bitcast %struct.widget* %tmp24 to i64** +define void @quux_skip(ptr noalias %f, ptr noalias %g) align 2 { + %tmp = getelementptr inbounds %struct.hoge, ptr %f, i64 0, i32 1, i32 0 + %tmp24 = getelementptr inbounds %struct.hoge, ptr %f, i64 0, i32 1 br label %bb26 bb26: ; preds = %bb77, %0 @@ -76,73 +73,71 @@ bb26: ; preds = %bb77, %0 bb68: ; preds = %bb26 ; CHECK: MemoryUse(3) -; CHECK-NEXT: %tmp69 = load i64, i64* %g, align 8 - %tmp69 = load i64, i64* %g, align 8 +; CHECK-NEXT: %tmp69 = load i64, ptr %g, align 8 + %tmp69 = load i64, ptr %g, align 8 ; CHECK: 1 = MemoryDef(3) -; CHECK-NEXT: store i64 %tmp69, i64* %g, align 8 - store i64 %tmp69, i64* %g, align 8 +; CHECK-NEXT: store i64 %tmp69, ptr %g, align 8 + store i64 %tmp69, ptr %g, align 8 br label %bb77 bb77: ; preds = %bb68, %bb26 ; CHECK: 2 = MemoryPhi({bb26,3},{bb68,1}) ; CHECK: MemoryUse(liveOnEntry) -; CHECK-NEXT: %tmp78 = load i64*, i64** %tmp25, align 8 - %tmp78 = load i64*, i64** %tmp25, align 8 +; CHECK-NEXT: %tmp78 = load ptr, ptr %tmp24, align 8 + %tmp78 = load ptr, ptr %tmp24, align 8 br label %bb26 } ; CHECK-LABEL: define void @quux_dominated -define void @quux_dominated(%struct.hoge* noalias %f, i64* noalias %g) align 2 { - %tmp = getelementptr inbounds %struct.hoge, %struct.hoge* %f, i64 0, i32 1, i32 0 - %tmp24 = getelementptr inbounds %struct.hoge, %struct.hoge* %f, i64 0, i32 1 - %tmp25 = bitcast %struct.widget* %tmp24 to i64** +define void @quux_dominated(ptr noalias %f, ptr noalias %g) align 2 { + %tmp = getelementptr inbounds %struct.hoge, ptr %f, i64 0, i32 1, i32 0 + %tmp24 = getelementptr inbounds %struct.hoge, ptr %f, i64 0, i32 1 br label %bb26 bb26: ; preds = %bb77, %0 ; CHECK: 3 = MemoryPhi({%0,liveOnEntry},{bb77,2}) ; CHECK: MemoryUse(3) -; CHECK-NEXT: load i64*, i64** %tmp25, align 8 - load i64*, i64** %tmp25, align 8 +; CHECK-NEXT: load ptr, ptr %tmp24, align 8 + load ptr, ptr %tmp24, align 8 br i1 undef, label %bb68, label %bb77 bb68: ; preds = %bb26 ; CHECK: MemoryUse(3) -; CHECK-NEXT: %tmp69 = load i64, i64* %g, align 8 - %tmp69 = load i64, i64* %g, align 8 +; CHECK-NEXT: %tmp69 = load i64, ptr %g, align 8 + %tmp69 = load i64, ptr %g, align 8 ; CHECK: 1 = MemoryDef(3) -; CHECK-NEXT: store i64 %tmp69, i64* %g, align 8 - store i64 %tmp69, i64* %g, align 8 +; CHECK-NEXT: store i64 %tmp69, ptr %g, align 8 + store i64 %tmp69, ptr %g, align 8 br label %bb77 bb77: ; preds = %bb68, %bb26 ; CHECK: 4 = MemoryPhi({bb26,3},{bb68,1}) ; CHECK: 2 = MemoryDef(4) -; CHECK-NEXT: store i64* null, i64** %tmp25, align 8 - store i64* null, i64** %tmp25, align 8 +; CHECK-NEXT: store ptr null, ptr %tmp24, align 8 + store ptr null, ptr %tmp24, align 8 br label %bb26 } ; CHECK-LABEL: define void @quux_nodominate -define void @quux_nodominate(%struct.hoge* noalias %f, i64* noalias %g) align 2 { - %tmp = getelementptr inbounds %struct.hoge, %struct.hoge* %f, i64 0, i32 1, i32 0 - %tmp24 = getelementptr inbounds %struct.hoge, %struct.hoge* %f, i64 0, i32 1 - %tmp25 = bitcast %struct.widget* %tmp24 to i64** +define void @quux_nodominate(ptr noalias %f, ptr noalias %g) align 2 { + %tmp = getelementptr inbounds %struct.hoge, ptr %f, i64 0, i32 1, i32 0 + %tmp24 = getelementptr inbounds %struct.hoge, ptr %f, i64 0, i32 1 br label %bb26 bb26: ; preds = %bb77, %0 ; CHECK: 3 = MemoryPhi({%0,liveOnEntry},{bb77,2}) ; CHECK: MemoryUse(liveOnEntry) -; CHECK-NEXT: load i64*, i64** %tmp25, align 8 - load i64*, i64** %tmp25, align 8 +; CHECK-NEXT: load ptr, ptr %tmp24, align 8 + load ptr, ptr %tmp24, align 8 br i1 undef, label %bb68, label %bb77 bb68: ; preds = %bb26 ; CHECK: MemoryUse(3) -; CHECK-NEXT: %tmp69 = load i64, i64* %g, align 8 - %tmp69 = load i64, i64* %g, align 8 +; CHECK-NEXT: %tmp69 = load i64, ptr %g, align 8 + %tmp69 = load i64, ptr %g, align 8 ; CHECK: 1 = MemoryDef(3) -; CHECK-NEXT: store i64 %tmp69, i64* %g, align 8 - store i64 %tmp69, i64* %g, align 8 +; CHECK-NEXT: store i64 %tmp69, ptr %g, align 8 + store i64 %tmp69, ptr %g, align 8 br label %bb77 bb77: ; preds = %bb68, %bb26 diff --git a/llvm/test/Analysis/MemorySSA/debugvalue.ll b/llvm/test/Analysis/MemorySSA/debugvalue.ll index a0b9b63ef64a..7d8e87a2d840 100644 --- a/llvm/test/Analysis/MemorySSA/debugvalue.ll +++ b/llvm/test/Analysis/MemorySSA/debugvalue.ll @@ -15,7 +15,7 @@ for.cond.cleanup: ; preds = %for.cond ret void for.body: ; preds = %for.cond - store i32 undef, i32* undef, align 1 + store i32 undef, ptr undef, align 1 %inc = add i16 %i.0, 1 call void @llvm.dbg.value(metadata i16 %inc, metadata !32, metadata !DIExpression()), !dbg !31 br label %for.cond diff --git a/llvm/test/Analysis/MemorySSA/debugvalue2.ll b/llvm/test/Analysis/MemorySSA/debugvalue2.ll index 05cad73071cf..4565e3f7bc56 100644 --- a/llvm/test/Analysis/MemorySSA/debugvalue2.ll +++ b/llvm/test/Analysis/MemorySSA/debugvalue2.ll @@ -19,7 +19,7 @@ for.cond: ; preds = %for.body, %entry br i1 undef, label %for.end, label %for.body for.body: ; preds = %for.cond - %0 = load i16, i16* undef, align 1 + %0 = load i16, ptr undef, align 1 br label %for.cond for.end: ; preds = %for.cond diff --git a/llvm/test/Analysis/MemorySSA/forward-unreachable.ll b/llvm/test/Analysis/MemorySSA/forward-unreachable.ll index 2bbf399daae4..aead6277a1fb 100644 --- a/llvm/test/Analysis/MemorySSA/forward-unreachable.ll +++ b/llvm/test/Analysis/MemorySSA/forward-unreachable.ll @@ -6,7 +6,7 @@ entry: br i1 undef, label %split1, label %split2 split1: - store i16 undef, i16* undef, align 2 + store i16 undef, ptr undef, align 2 br label %merge split2: br label %merge @@ -17,7 +17,7 @@ merge: ; because it is reverse reachable, so the CFG still has it as a ; predecessor of the block ; CHECK: 3 = MemoryPhi({split1,1},{split2,liveOnEntry},{forwardunreachable,liveOnEntry}) - store i16 undef, i16* undef, align 2 + store i16 undef, ptr undef, align 2 ret void } diff --git a/llvm/test/Analysis/MemorySSA/function-clobber.ll b/llvm/test/Analysis/MemorySSA/function-clobber.ll index dd1df96b04b0..53662b1930c3 100644 --- a/llvm/test/Analysis/MemorySSA/function-clobber.ll +++ b/llvm/test/Analysis/MemorySSA/function-clobber.ll @@ -8,11 +8,11 @@ declare void @modifyG() define i32 @foo() { ; CHECK: MemoryUse(liveOnEntry) ; CHECK-NEXT: %1 = load i32 - %1 = load i32, i32* @g + %1 = load i32, ptr @g ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i32 4 - store i32 4, i32* @g, align 4 + store i32 4, ptr @g, align 4 ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: call void @modifyG() @@ -20,7 +20,7 @@ define i32 @foo() { ; CHECK: MemoryUse(2) ; CHECK-NEXT: %2 = load i32 - %2 = load i32, i32* @g + %2 = load i32, ptr @g %3 = add i32 %2, %1 ret i32 %3 } diff --git a/llvm/test/Analysis/MemorySSA/function-mem-attrs.ll b/llvm/test/Analysis/MemorySSA/function-mem-attrs.ll index 3758e91aa679..f3f9faf53a30 100644 --- a/llvm/test/Analysis/MemorySSA/function-mem-attrs.ll +++ b/llvm/test/Analysis/MemorySSA/function-mem-attrs.ll @@ -10,12 +10,12 @@ declare void @noattrsFunction() define void @readonlyAttr() { ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i32 0 - store i32 0, i32* @g, align 4 + store i32 0, ptr @g, align 4 %1 = alloca i32, align 4 ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: store i32 0 - store i32 0, i32* %1, align 4 + store i32 0, ptr %1, align 4 ; CHECK: MemoryUse(1) ; CHECK-NEXT: call void @readonlyFunction() @@ -33,26 +33,26 @@ define void @readonlyAttr() { ret void } -declare void @argMemOnly(i32*) argmemonly +declare void @argMemOnly(ptr) argmemonly define void @inaccessableOnlyAttr() { %1 = alloca i32, align 4 ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i32 0 - store i32 0, i32* %1, align 4 + store i32 0, ptr %1, align 4 ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: store i32 0 - store i32 0, i32* @g, align 4 + store i32 0, ptr @g, align 4 ; CHECK: MemoryUse(1) -; CHECK-NEXT: call void @argMemOnly(i32* %1) # +; CHECK-NEXT: call void @argMemOnly(ptr %1) # ; Assume that #N is readonly - call void @argMemOnly(i32* %1) readonly + call void @argMemOnly(ptr %1) readonly ; CHECK: 3 = MemoryDef(2) -; CHECK-NEXT: call void @argMemOnly(i32* %1) - call void @argMemOnly(i32* %1) +; CHECK-NEXT: call void @argMemOnly(ptr %1) + call void @argMemOnly(ptr %1) ret void } diff --git a/llvm/test/Analysis/MemorySSA/invalidate.ll b/llvm/test/Analysis/MemorySSA/invalidate.ll index 99faf8bed511..80d3504a6997 100644 --- a/llvm/test/Analysis/MemorySSA/invalidate.ll +++ b/llvm/test/Analysis/MemorySSA/invalidate.ll @@ -35,19 +35,17 @@ ; Function Attrs: ssp uwtable define i32 @main() { entry: - %call = call noalias i8* @_Znwm(i64 4) - %0 = bitcast i8* %call to i32* - %call1 = call noalias i8* @_Znwm(i64 4) - %1 = bitcast i8* %call1 to i32* - store i32 5, i32* %0, align 4 - store i32 7, i32* %1, align 4 - %2 = load i32, i32* %0, align 4 - %3 = load i32, i32* %1, align 4 - %4 = load i32, i32* %0, align 4 - %5 = load i32, i32* %1, align 4 - %add = add nsw i32 %3, %5 + %call = call noalias ptr @_Znwm(i64 4) + %call1 = call noalias ptr @_Znwm(i64 4) + store i32 5, ptr %call, align 4 + store i32 7, ptr %call1, align 4 + %0 = load i32, ptr %call, align 4 + %1 = load i32, ptr %call1, align 4 + %2 = load i32, ptr %call, align 4 + %3 = load i32, ptr %call1, align 4 + %add = add nsw i32 %1, %3 ret i32 %add } -declare noalias i8* @_Znwm(i64) +declare noalias ptr @_Znwm(i64) diff --git a/llvm/test/Analysis/MemorySSA/invariant-groups.ll b/llvm/test/Analysis/MemorySSA/invariant-groups.ll index 9a4bbb5c859b..8d1ec5226be5 100644 --- a/llvm/test/Analysis/MemorySSA/invariant-groups.ll +++ b/llvm/test/Analysis/MemorySSA/invariant-groups.ll @@ -6,17 +6,17 @@ define i32 @global() { ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i32 0 - store i32 0, i32* @g, align 4, !invariant.group !0 + store i32 0, ptr @g, align 4, !invariant.group !0 ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: call void @clobber - call void @clobber(i32* @g) + call void @clobber(ptr @g) ; FIXME: this could be clobbered by 1 if we walked the instruction list for loads/stores to @g. ; But we can't look at the uses of @g in a function analysis. ; CHECK: MemoryUse(2) {{.*}} clobbered by 2 ; CHECK-NEXT: %1 = load i32 - %1 = load i32, i32* @g, align 4, !invariant.group !0 + %1 = load i32, ptr @g, align 4, !invariant.group !0 ret i32 %1 } @@ -24,153 +24,145 @@ define i32 @global() { define i32 @global2() { ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i32 0 - store i32 0, i32* inttoptr (i64 ptrtoint (i32* @g to i64) to i32*), align 4, !invariant.group !0 + store i32 0, ptr inttoptr (i64 ptrtoint (ptr @g to i64) to ptr), align 4, !invariant.group !0 ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: call void @clobber - call void @clobber(i32* inttoptr (i64 ptrtoint (i32* @g to i64) to i32*)) + call void @clobber(ptr inttoptr (i64 ptrtoint (ptr @g to i64) to ptr)) ; FIXME: this could be clobbered by 1 if we walked the instruction list for loads/stores to @g. ; But we can't look at the uses of @g in a function analysis. ; CHECK: MemoryUse(2) {{.*}} clobbered by 2 ; CHECK-NEXT: %1 = load i32 - %1 = load i32, i32* inttoptr (i64 ptrtoint (i32* @g to i64) to i32*), align 4, !invariant.group !0 + %1 = load i32, ptr inttoptr (i64 ptrtoint (ptr @g to i64) to ptr), align 4, !invariant.group !0 ret i32 %1 } ; CHECK-LABEL: define {{.*}} @foo( -define i32 @foo(i32* %a) { +define i32 @foo(ptr %a) { ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i32 0 - store i32 0, i32* %a, align 4, !invariant.group !0 + store i32 0, ptr %a, align 4, !invariant.group !0 ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: store i32 1 - store i32 1, i32* @g, align 4 + store i32 1, ptr @g, align 4 - %1 = bitcast i32* %a to i8* ; CHECK: 3 = MemoryDef(2) -; CHECK-NEXT: %a8 = call i8* @llvm.launder.invariant.group.p0i8(i8* %1) - %a8 = call i8* @llvm.launder.invariant.group.p0i8(i8* %1) - %a32 = bitcast i8* %a8 to i32* +; CHECK-NEXT: %a8 = call ptr @llvm.launder.invariant.group.p0(ptr %a) + %a8 = call ptr @llvm.launder.invariant.group.p0(ptr %a) ; This have to be MemoryUse(2), because we can't skip the barrier based on ; invariant.group. ; CHECK: MemoryUse(2) -; CHECK-NEXT: %2 = load i32 - %2 = load i32, i32* %a32, align 4, !invariant.group !0 - ret i32 %2 +; CHECK-NEXT: %1 = load i32 + %1 = load i32, ptr %a8, align 4, !invariant.group !0 + ret i32 %1 } ; CHECK-LABEL: define {{.*}} @volatile1( -define void @volatile1(i32* %a) { +define void @volatile1(ptr %a) { ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i32 0 - store i32 0, i32* %a, align 4, !invariant.group !0 + store i32 0, ptr %a, align 4, !invariant.group !0 ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: call void @clobber - call void @clobber(i32* %a) + call void @clobber(ptr %a) ; CHECK: 3 = MemoryDef(2){{.*}} clobbered by 2 ; CHECK-NEXT: load volatile - %b = load volatile i32, i32* %a, align 4, !invariant.group !0 + %b = load volatile i32, ptr %a, align 4, !invariant.group !0 ret void } ; CHECK-LABEL: define {{.*}} @volatile2( -define void @volatile2(i32* %a) { +define void @volatile2(ptr %a) { ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store volatile i32 0 - store volatile i32 0, i32* %a, align 4, !invariant.group !0 + store volatile i32 0, ptr %a, align 4, !invariant.group !0 ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: call void @clobber - call void @clobber(i32* %a) + call void @clobber(ptr %a) ; CHECK: MemoryUse(2){{.*}} clobbered by 2 ; CHECK-NEXT: load i32 - %b = load i32, i32* %a, align 4, !invariant.group !0 + %b = load i32, ptr %a, align 4, !invariant.group !0 ret void } ; CHECK-LABEL: define {{.*}} @skipBarrier( -define i32 @skipBarrier(i32* %a) { +define i32 @skipBarrier(ptr %a) { ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i32 0 - store i32 0, i32* %a, align 4, !invariant.group !0 + store i32 0, ptr %a, align 4, !invariant.group !0 - %1 = bitcast i32* %a to i8* ; CHECK: 2 = MemoryDef(1) -; CHECK-NEXT: %a8 = call i8* @llvm.launder.invariant.group.p0i8(i8* %1) - %a8 = call i8* @llvm.launder.invariant.group.p0i8(i8* %1) - %a32 = bitcast i8* %a8 to i32* +; CHECK-NEXT: %a8 = call ptr @llvm.launder.invariant.group.p0(ptr %a) + %a8 = call ptr @llvm.launder.invariant.group.p0(ptr %a) ; We can skip the barrier only if the "skip" is not based on !invariant.group. ; CHECK: MemoryUse(1) -; CHECK-NEXT: %2 = load i32 - %2 = load i32, i32* %a32, align 4, !invariant.group !0 - ret i32 %2 +; CHECK-NEXT: %1 = load i32 + %1 = load i32, ptr %a8, align 4, !invariant.group !0 + ret i32 %1 } ; CHECK-LABEL: define {{.*}} @skipBarrier2( -define i32 @skipBarrier2(i32* %a) { +define i32 @skipBarrier2(ptr %a) { ; CHECK: MemoryUse(liveOnEntry) ; CHECK-NEXT: %v = load i32 - %v = load i32, i32* %a, align 4, !invariant.group !0 + %v = load i32, ptr %a, align 4, !invariant.group !0 - %1 = bitcast i32* %a to i8* ; CHECK: 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: %a8 = call i8* @llvm.launder.invariant.group.p0i8(i8* %1) - %a8 = call i8* @llvm.launder.invariant.group.p0i8(i8* %1) - %a32 = bitcast i8* %a8 to i32* +; CHECK-NEXT: %a8 = call ptr @llvm.launder.invariant.group.p0(ptr %a) + %a8 = call ptr @llvm.launder.invariant.group.p0(ptr %a) ; We can skip the barrier only if the "skip" is not based on !invariant.group. ; CHECK: MemoryUse(liveOnEntry) ; CHECK-NEXT: %v2 = load i32 - %v2 = load i32, i32* %a32, align 4, !invariant.group !0 + %v2 = load i32, ptr %a8, align 4, !invariant.group !0 ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: store i32 1 - store i32 1, i32* @g, align 4 + store i32 1, ptr @g, align 4 ; CHECK: MemoryUse(2) {{.*}} clobbered by liveOnEntry ; CHECK-NEXT: %v3 = load i32 - %v3 = load i32, i32* %a32, align 4, !invariant.group !0 + %v3 = load i32, ptr %a8, align 4, !invariant.group !0 %add = add nsw i32 %v2, %v3 %add2 = add nsw i32 %add, %v ret i32 %add2 } ; CHECK-LABEL: define {{.*}} @handleInvariantGroups( -define i32 @handleInvariantGroups(i32* %a) { +define i32 @handleInvariantGroups(ptr %a) { ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i32 0 - store i32 0, i32* %a, align 4, !invariant.group !0 + store i32 0, ptr %a, align 4, !invariant.group !0 ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: store i32 1 - store i32 1, i32* @g, align 4 - %1 = bitcast i32* %a to i8* + store i32 1, ptr @g, align 4 ; CHECK: 3 = MemoryDef(2) -; CHECK-NEXT: %a8 = call i8* @llvm.launder.invariant.group.p0i8(i8* %1) - %a8 = call i8* @llvm.launder.invariant.group.p0i8(i8* %1) - %a32 = bitcast i8* %a8 to i32* +; CHECK-NEXT: %a8 = call ptr @llvm.launder.invariant.group.p0(ptr %a) + %a8 = call ptr @llvm.launder.invariant.group.p0(ptr %a) ; CHECK: MemoryUse(2) -; CHECK-NEXT: %2 = load i32 - %2 = load i32, i32* %a32, align 4, !invariant.group !0 +; CHECK-NEXT: %1 = load i32 + %1 = load i32, ptr %a8, align 4, !invariant.group !0 ; CHECK: 4 = MemoryDef(3) ; CHECK-NEXT: store i32 2 - store i32 2, i32* @g, align 4 + store i32 2, ptr @g, align 4 ; CHECK: MemoryUse(4) {{.*}} clobbered by 2 -; CHECK-NEXT: %3 = load i32 - %3 = load i32, i32* %a32, align 4, !invariant.group !0 - %add = add nsw i32 %2, %3 +; CHECK-NEXT: %2 = load i32 + %2 = load i32, ptr %a8, align 4, !invariant.group !0 + %add = add nsw i32 %1, %2 ret i32 %add } @@ -180,22 +172,22 @@ entry: %0 = alloca i32, align 4 ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i32 4 - store i32 4, i32* %0, !invariant.group !0 + store i32 4, ptr %0, !invariant.group !0 ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: call void @clobber - call void @clobber(i32* %0) + call void @clobber(ptr %0) br i1 %a, label %Loop.Body, label %Loop.End Loop.Body: ; CHECK: MemoryUse(2) {{.*}} clobbered by 1 ; CHECK-NEXT: %1 = load i32 - %1 = load i32, i32* %0, !invariant.group !0 + %1 = load i32, ptr %0, !invariant.group !0 br i1 %a, label %Loop.End, label %Loop.Body Loop.End: ; CHECK: MemoryUse(2) {{.*}} clobbered by 1 ; CHECK-NEXT: %2 = load - %2 = load i32, i32* %0, align 4, !invariant.group !0 + %2 = load i32, ptr %0, align 4, !invariant.group !0 br i1 %a, label %Ret, label %Loop.Body Ret: @@ -203,42 +195,42 @@ Ret: } ; CHECK-LABEL: define {{.*}} @loop2( -define i8 @loop2(i8* %p) { +define i8 @loop2(ptr %p) { entry: ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i8 - store i8 4, i8* %p, !invariant.group !0 + store i8 4, ptr %p, !invariant.group !0 ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: call void @clobber - call void @clobber8(i8* %p) + call void @clobber8(ptr %p) ; CHECK: 3 = MemoryDef(2) -; CHECK-NEXT: %after = call i8* @llvm.launder.invariant.group.p0i8(i8* %p) - %after = call i8* @llvm.launder.invariant.group.p0i8(i8* %p) +; CHECK-NEXT: %after = call ptr @llvm.launder.invariant.group.p0(ptr %p) + %after = call ptr @llvm.launder.invariant.group.p0(ptr %p) br i1 undef, label %Loop.Body, label %Loop.End Loop.Body: ; CHECK: MemoryUse(6) ; CHECK-NEXT: %0 = load i8 - %0 = load i8, i8* %after, !invariant.group !0 + %0 = load i8, ptr %after, !invariant.group !0 ; CHECK: MemoryUse(6) {{.*}} clobbered by 1 ; CHECK-NEXT: %1 = load i8 - %1 = load i8, i8* %p, !invariant.group !0 + %1 = load i8, ptr %p, !invariant.group !0 ; CHECK: 4 = MemoryDef(6) - store i8 4, i8* %after, !invariant.group !0 + store i8 4, ptr %after, !invariant.group !0 br i1 undef, label %Loop.End, label %Loop.Body Loop.End: ; CHECK: MemoryUse(5) ; CHECK-NEXT: %2 = load - %2 = load i8, i8* %after, align 4, !invariant.group !0 + %2 = load i8, ptr %after, align 4, !invariant.group !0 ; CHECK: MemoryUse(5) {{.*}} clobbered by 1 ; CHECK-NEXT: %3 = load - %3 = load i8, i8* %p, align 4, !invariant.group !0 + %3 = load i8, ptr %p, align 4, !invariant.group !0 br i1 undef, label %Ret, label %Loop.Body Ret: @@ -247,57 +239,57 @@ Ret: ; CHECK-LABEL: define {{.*}} @loop3( -define i8 @loop3(i8* %p) { +define i8 @loop3(ptr %p) { entry: ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i8 - store i8 4, i8* %p, !invariant.group !0 + store i8 4, ptr %p, !invariant.group !0 ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: call void @clobber - call void @clobber8(i8* %p) + call void @clobber8(ptr %p) ; CHECK: 3 = MemoryDef(2) -; CHECK-NEXT: %after = call i8* @llvm.launder.invariant.group.p0i8(i8* %p) - %after = call i8* @llvm.launder.invariant.group.p0i8(i8* %p) +; CHECK-NEXT: %after = call ptr @llvm.launder.invariant.group.p0(ptr %p) + %after = call ptr @llvm.launder.invariant.group.p0(ptr %p) br i1 undef, label %Loop.Body, label %Loop.End Loop.Body: ; CHECK: MemoryUse(8) ; CHECK-NEXT: %0 = load i8 - %0 = load i8, i8* %after, !invariant.group !0 + %0 = load i8, ptr %after, !invariant.group !0 ; CHECK: 4 = MemoryDef(8) ; CHECK-NEXT: call void @clobber8 - call void @clobber8(i8* %after) + call void @clobber8(ptr %after) ; CHECK: MemoryUse(4) {{.*}} clobbered by 8 ; CHECK-NEXT: %1 = load i8 - %1 = load i8, i8* %after, !invariant.group !0 + %1 = load i8, ptr %after, !invariant.group !0 br i1 undef, label %Loop.next, label %Loop.Body Loop.next: ; CHECK: 5 = MemoryDef(4) ; CHECK-NEXT: call void @clobber8 - call void @clobber8(i8* %after) + call void @clobber8(ptr %after) ; CHECK: MemoryUse(5) {{.*}} clobbered by 8 ; CHECK-NEXT: %2 = load i8 - %2 = load i8, i8* %after, !invariant.group !0 + %2 = load i8, ptr %after, !invariant.group !0 br i1 undef, label %Loop.End, label %Loop.Body Loop.End: ; CHECK: MemoryUse(7) ; CHECK-NEXT: %3 = load - %3 = load i8, i8* %after, align 4, !invariant.group !0 + %3 = load i8, ptr %after, align 4, !invariant.group !0 ; CHECK: 6 = MemoryDef(7) ; CHECK-NEXT: call void @clobber8 - call void @clobber8(i8* %after) + call void @clobber8(ptr %after) ; CHECK: MemoryUse(6) {{.*}} clobbered by 7 ; CHECK-NEXT: %4 = load - %4 = load i8, i8* %after, align 4, !invariant.group !0 + %4 = load i8, ptr %after, align 4, !invariant.group !0 br i1 undef, label %Ret, label %Loop.Body Ret: @@ -305,45 +297,45 @@ Ret: } ; CHECK-LABEL: define {{.*}} @loop4( -define i8 @loop4(i8* %p) { +define i8 @loop4(ptr %p) { entry: ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i8 - store i8 4, i8* %p, !invariant.group !0 + store i8 4, ptr %p, !invariant.group !0 ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: call void @clobber - call void @clobber8(i8* %p) + call void @clobber8(ptr %p) ; CHECK: 3 = MemoryDef(2) -; CHECK-NEXT: %after = call i8* @llvm.launder.invariant.group.p0i8(i8* %p) - %after = call i8* @llvm.launder.invariant.group.p0i8(i8* %p) +; CHECK-NEXT: %after = call ptr @llvm.launder.invariant.group.p0(ptr %p) + %after = call ptr @llvm.launder.invariant.group.p0(ptr %p) br i1 undef, label %Loop.Pre, label %Loop.End Loop.Pre: ; CHECK: MemoryUse(2) ; CHECK-NEXT: %0 = load i8 - %0 = load i8, i8* %after, !invariant.group !0 + %0 = load i8, ptr %after, !invariant.group !0 br label %Loop.Body Loop.Body: ; CHECK: MemoryUse(6) ; CHECK-NEXT: %1 = load i8 - %1 = load i8, i8* %after, !invariant.group !0 + %1 = load i8, ptr %after, !invariant.group !0 ; CHECK: MemoryUse(6) {{.*}} clobbered by 1 ; CHECK-NEXT: %2 = load i8 - %2 = load i8, i8* %p, !invariant.group !0 + %2 = load i8, ptr %p, !invariant.group !0 ; CHECK: 4 = MemoryDef(6) - store i8 4, i8* %after, !invariant.group !0 + store i8 4, ptr %after, !invariant.group !0 br i1 undef, label %Loop.End, label %Loop.Body Loop.End: ; CHECK: MemoryUse(5) ; CHECK-NEXT: %3 = load - %3 = load i8, i8* %after, align 4, !invariant.group !0 + %3 = load i8, ptr %after, align 4, !invariant.group !0 ; CHECK: MemoryUse(5) {{.*}} clobbered by 1 ; CHECK-NEXT: %4 = load - %4 = load i8, i8* %p, align 4, !invariant.group !0 + %4 = load i8, ptr %p, align 4, !invariant.group !0 br i1 undef, label %Ret, label %Loop.Body Ret: @@ -356,27 +348,27 @@ define i8 @optimizable() { entry: %ptr = alloca i8 ; CHECK: 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: store i8 42, i8* %ptr, align 1, !invariant.group !0 - store i8 42, i8* %ptr, !invariant.group !0 +; CHECK-NEXT: store i8 42, ptr %ptr, align 1, !invariant.group !0 + store i8 42, ptr %ptr, !invariant.group !0 ; CHECK: 2 = MemoryDef(1) -; CHECK-NEXT: call i8* @llvm.launder.invariant.group - %ptr2 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr) +; CHECK-NEXT: call ptr @llvm.launder.invariant.group + %ptr2 = call ptr @llvm.launder.invariant.group.p0(ptr %ptr) ; FIXME: This one could be CSEd. ; CHECK: 3 = MemoryDef(2) -; CHECK: call i8* @llvm.launder.invariant.group - %ptr3 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr) +; CHECK: call ptr @llvm.launder.invariant.group + %ptr3 = call ptr @llvm.launder.invariant.group.p0(ptr %ptr) ; CHECK: 4 = MemoryDef(3) -; CHECK-NEXT: call void @clobber8(i8* %ptr) - call void @clobber8(i8* %ptr) +; CHECK-NEXT: call void @clobber8(ptr %ptr) + call void @clobber8(ptr %ptr) ; CHECK: 5 = MemoryDef(4) -; CHECK-NEXT: call void @use(i8* %ptr2) - call void @use(i8* %ptr2) +; CHECK-NEXT: call void @use(ptr %ptr2) + call void @use(ptr %ptr2) ; CHECK: 6 = MemoryDef(5) -; CHECK-NEXT: call void @use(i8* %ptr3) - call void @use(i8* %ptr3) +; CHECK-NEXT: call void @use(ptr %ptr3) + call void @use(ptr %ptr3) ; CHECK: MemoryUse(6) -; CHECK-NEXT: load i8, i8* %ptr3, {{.*}}!invariant.group - %v = load i8, i8* %ptr3, !invariant.group !0 +; CHECK-NEXT: load i8, ptr %ptr3, {{.*}}!invariant.group + %v = load i8, ptr %ptr3, !invariant.group !0 ret i8 %v } @@ -385,35 +377,35 @@ entry: define i8 @unoptimizable2() { %ptr = alloca i8 ; CHECK: 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: store i8 42, i8* %ptr, align 1, !invariant.group !0 - store i8 42, i8* %ptr, !invariant.group !0 +; CHECK-NEXT: store i8 42, ptr %ptr, align 1, !invariant.group !0 + store i8 42, ptr %ptr, !invariant.group !0 ; CHECK: 2 = MemoryDef(1) -; CHECK-NEXT: call i8* @llvm.launder.invariant.group - %ptr2 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr) +; CHECK-NEXT: call ptr @llvm.launder.invariant.group + %ptr2 = call ptr @llvm.launder.invariant.group.p0(ptr %ptr) ; CHECK: 3 = MemoryDef(2) - store i8 43, i8* %ptr + store i8 43, ptr %ptr ; CHECK: 4 = MemoryDef(3) -; CHECK-NEXT: call i8* @llvm.launder.invariant.group - %ptr3 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr) +; CHECK-NEXT: call ptr @llvm.launder.invariant.group + %ptr3 = call ptr @llvm.launder.invariant.group.p0(ptr %ptr) ; CHECK: 5 = MemoryDef(4) -; CHECK-NEXT: call void @clobber8(i8* %ptr) - call void @clobber8(i8* %ptr) +; CHECK-NEXT: call void @clobber8(ptr %ptr) + call void @clobber8(ptr %ptr) ; CHECK: 6 = MemoryDef(5) -; CHECK-NEXT: call void @use(i8* %ptr2) - call void @use(i8* %ptr2) +; CHECK-NEXT: call void @use(ptr %ptr2) + call void @use(ptr %ptr2) ; CHECK: 7 = MemoryDef(6) -; CHECK-NEXT: call void @use(i8* %ptr3) - call void @use(i8* %ptr3) +; CHECK-NEXT: call void @use(ptr %ptr3) + call void @use(ptr %ptr3) ; CHECK: MemoryUse(7) -; CHECK-NEXT: %v = load i8, i8* %ptr3, align 1, !invariant.group !0 - %v = load i8, i8* %ptr3, !invariant.group !0 +; CHECK-NEXT: %v = load i8, ptr %ptr3, align 1, !invariant.group !0 + %v = load i8, ptr %ptr3, !invariant.group !0 ret i8 %v } -declare i8* @llvm.launder.invariant.group.p0i8(i8*) -declare void @clobber(i32*) -declare void @clobber8(i8*) -declare void @use(i8* readonly) +declare ptr @llvm.launder.invariant.group.p0(ptr) +declare void @clobber(ptr) +declare void @clobber8(ptr) +declare void @use(ptr readonly) !0 = !{!"group1"} diff --git a/llvm/test/Analysis/MemorySSA/lifetime-simple.ll b/llvm/test/Analysis/MemorySSA/lifetime-simple.ll index 9d3de796d3cf..d409c140dc7b 100644 --- a/llvm/test/Analysis/MemorySSA/lifetime-simple.ll +++ b/llvm/test/Analysis/MemorySSA/lifetime-simple.ll @@ -2,27 +2,27 @@ ; This test checks that lifetime markers are considered clobbers of %P, ; and due to lack of noalias information, of %Q as well. -define i8 @test(i8* %P, i8* %Q) { +define i8 @test(ptr %P, ptr %Q) { entry: ; CHECK: 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 32, i8* %P) - call void @llvm.lifetime.start.p0i8(i64 32, i8* %P) +; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 32, ptr %P) + call void @llvm.lifetime.start.p0(i64 32, ptr %P) ; CHECK: MemoryUse(1) -; CHECK-NEXT: %0 = load i8, i8* %P - %0 = load i8, i8* %P +; CHECK-NEXT: %0 = load i8, ptr %P + %0 = load i8, ptr %P ; CHECK: 2 = MemoryDef(1) -; CHECK-NEXT: store i8 1, i8* %P - store i8 1, i8* %P +; CHECK-NEXT: store i8 1, ptr %P + store i8 1, ptr %P ; CHECK: 3 = MemoryDef(2) -; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 32, i8* %P) - call void @llvm.lifetime.end.p0i8(i64 32, i8* %P) +; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 32, ptr %P) + call void @llvm.lifetime.end.p0(i64 32, ptr %P) ; CHECK: MemoryUse(3) -; CHECK-NEXT: %1 = load i8, i8* %P - %1 = load i8, i8* %P +; CHECK-NEXT: %1 = load i8, ptr %P + %1 = load i8, ptr %P ; CHECK: MemoryUse(3) -; CHECK-NEXT: %2 = load i8, i8* %Q - %2 = load i8, i8* %Q +; CHECK-NEXT: %2 = load i8, ptr %Q + %2 = load i8, ptr %Q ret i8 %1 } -declare void @llvm.lifetime.start.p0i8(i64 %S, i8* nocapture %P) readonly -declare void @llvm.lifetime.end.p0i8(i64 %S, i8* nocapture %P) +declare void @llvm.lifetime.start.p0(i64 %S, ptr nocapture %P) readonly +declare void @llvm.lifetime.end.p0(i64 %S, ptr nocapture %P) diff --git a/llvm/test/Analysis/MemorySSA/load-invariant.ll b/llvm/test/Analysis/MemorySSA/load-invariant.ll index 3ae0b76e0fe9..a7c37afdf972 100644 --- a/llvm/test/Analysis/MemorySSA/load-invariant.ll +++ b/llvm/test/Analysis/MemorySSA/load-invariant.ll @@ -14,23 +14,23 @@ define i32 @foo() { call void @clobberAllTheThings() ; CHECK: MemoryUse(liveOnEntry) ; CHECK-NEXT: %1 = load i32 - %1 = load i32, i32* @g, align 4, !invariant.load !0 + %1 = load i32, ptr @g, align 4, !invariant.load !0 ret i32 %1 } ; CHECK-LABEL: define i32 @bar -define i32 @bar(i32* %a) { +define i32 @bar(ptr %a) { ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: call void @clobberAllTheThings() call void @clobberAllTheThings() ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: %1 = load atomic i32 - %1 = load atomic i32, i32* %a acquire, align 4, !invariant.load !0 + %1 = load atomic i32, ptr %a acquire, align 4, !invariant.load !0 ; CHECK: MemoryUse(2) ; CHECK-NEXT: %2 = load i32 - %2 = load i32, i32* %a, align 4 + %2 = load i32, ptr %a, align 4 ret i32 %2 } diff --git a/llvm/test/Analysis/MemorySSA/loop-rotate-disablebasicaa.ll b/llvm/test/Analysis/MemorySSA/loop-rotate-disablebasicaa.ll index 2e9316cd3e71..dcf83d2fe280 100644 --- a/llvm/test/Analysis/MemorySSA/loop-rotate-disablebasicaa.ll +++ b/llvm/test/Analysis/MemorySSA/loop-rotate-disablebasicaa.ll @@ -17,7 +17,7 @@ for.cond.cleanup126: ; preds = %for.cond120 unreachable for.body127: ; preds = %for.cond120 - %0 = load i16**, i16*** undef, align 1 + %0 = load ptr, ptr undef, align 1 br label %for.cond120 } diff --git a/llvm/test/Analysis/MemorySSA/loop-rotate-inv-template.ll b/llvm/test/Analysis/MemorySSA/loop-rotate-inv-template.ll index 0760d946ccc7..f302f86bf4bf 100644 --- a/llvm/test/Analysis/MemorySSA/loop-rotate-inv-template.ll +++ b/llvm/test/Analysis/MemorySSA/loop-rotate-inv-template.ll @@ -7,12 +7,12 @@ entry: br label %looplabel.exit.i looplabel.exit.i: ; preds = %if.end.i, %entry - %0 = phi i1 (i32*, i32*)* [ @foo, %entry ], [ undef, %if.end.i ] - %call3.i.i = call zeroext i1 %0(i32* nonnull dereferenceable(16) undef, i32* nonnull undef) + %0 = phi ptr [ @foo, %entry ], [ undef, %if.end.i ] + %call3.i.i = call zeroext i1 %0(ptr nonnull dereferenceable(16) undef, ptr nonnull undef) br i1 %call3.i.i, label %if.end.i, label %label.exit if.end.i: ; preds = %looplabel.exit.i - %tobool.i = icmp eq i32* undef, null + %tobool.i = icmp eq ptr undef, null br label %looplabel.exit.i label.exit: ; preds = %looplabel.exit.i @@ -20,7 +20,7 @@ label.exit: ; preds = %looplabel.exit.i } ; Function Attrs: readonly -declare dso_local i1 @foo(i32*, i32*) #1 align 32 +declare dso_local i1 @foo(ptr, ptr) #1 align 32 attributes #0 = { nounwind } attributes #1 = { readonly } diff --git a/llvm/test/Analysis/MemorySSA/loop-rotate-simplified-clone.ll b/llvm/test/Analysis/MemorySSA/loop-rotate-simplified-clone.ll index 8769d60b2663..aab65955a285 100644 --- a/llvm/test/Analysis/MemorySSA/loop-rotate-simplified-clone.ll +++ b/llvm/test/Analysis/MemorySSA/loop-rotate-simplified-clone.ll @@ -10,13 +10,13 @@ preheader: br label %l39 l39: - %v40 = phi float (float)* [ @foo, %preheader ], [ %v43, %crit_edge ] + %v40 = phi ptr [ @foo, %preheader ], [ %v43, %crit_edge ] %v41 = call float %v40(float undef) - %v42 = load i32, i32* undef, align 8 + %v42 = load i32, ptr undef, align 8 br i1 undef, label %crit_edge, label %loopexit crit_edge: - %v43 = load float (float)*, float (float)** undef, align 8 + %v43 = load ptr, ptr undef, align 8 br label %l39 loopexit: diff --git a/llvm/test/Analysis/MemorySSA/loop-rotate-valuemap.ll b/llvm/test/Analysis/MemorySSA/loop-rotate-valuemap.ll index 75fb0c61180b..c4679e00d4fc 100644 --- a/llvm/test/Analysis/MemorySSA/loop-rotate-valuemap.ll +++ b/llvm/test/Analysis/MemorySSA/loop-rotate-valuemap.ll @@ -14,11 +14,11 @@ for.cond.cleanup15: ; preds = %for.body16 for.body16: ; preds = %for.body16.for.body16_crit_edge, %entry %call.i = tail call float @expf(float 0.000000e+00) #1 - %0 = load float*, float** undef, align 8 + %0 = load ptr, ptr undef, align 8 br i1 undef, label %for.cond.cleanup15, label %for.body16.for.body16_crit_edge for.body16.for.body16_crit_edge: ; preds = %for.body16 - %.pre = load float, float* undef, align 8 + %.pre = load float, ptr undef, align 8 br label %for.body16 } diff --git a/llvm/test/Analysis/MemorySSA/loop_rotate_remove_trivial_phis.ll b/llvm/test/Analysis/MemorySSA/loop_rotate_remove_trivial_phis.ll index 9c8d16ed9b04..7903f7336436 100644 --- a/llvm/test/Analysis/MemorySSA/loop_rotate_remove_trivial_phis.ll +++ b/llvm/test/Analysis/MemorySSA/loop_rotate_remove_trivial_phis.ll @@ -7,13 +7,13 @@ target triple = "x86_64-grtev4-linux-gnu" declare double @sqrt(double) ; CHECK-LABEL: @f -define internal fastcc double @f(i32* %n_, double* %dx) align 32 { +define internal fastcc double @f(ptr %n_, ptr %dx) align 32 { entry: ; CHECK: entry: ; CHECK: MemoryUse(liveOnEntry) ; CHECK-NOT: 7 = MemoryPhi ; CHECK-NOT: 6 = MemoryPhi - %v0 = load i32, i32* %n_, align 4 + %v0 = load i32, ptr %n_, align 4 br label %for.cond for.cond: ; preds = %for.body, %entry @@ -24,8 +24,8 @@ for.cond: ; preds = %for.body, %entry for.body: ; preds = %for.cond %idxprom = zext i32 %i.0 to i64 - %arrayidx = getelementptr inbounds double, double* %dx, i64 %idxprom - %v1 = load double, double* %arrayidx, align 8 + %arrayidx = getelementptr inbounds double, ptr %dx, i64 %idxprom + %v1 = load double, ptr %arrayidx, align 8 %cmp1 = fcmp ueq double %v1, 0.000000e+00 %xmax.1 = select i1 %cmp1, double %xmax.0, double %v1 %inc = add nuw nsw i32 %i.0, 1 @@ -50,8 +50,8 @@ for.body7: ; preds = %for.body7.lr.ph, %f %i.13 = phi i32 [ 0, %for.body7.lr.ph ], [ %inc14, %for.body7 ] %sum.02 = phi x86_fp80 [ undef, %for.body7.lr.ph ], [ %add, %for.body7 ] %idxprom9 = zext i32 %i.13 to i64 - %arrayidx10 = getelementptr inbounds double, double* %dx, i64 %idxprom9 - %v3 = load double, double* %arrayidx10, align 8 + %arrayidx10 = getelementptr inbounds double, ptr %dx, i64 %idxprom9 + %v3 = load double, ptr %arrayidx10, align 8 %mul11 = fmul double %div, %v3 %v2 = call double @sqrt(double %v3) %mul12 = fmul double %mul11, %v2 diff --git a/llvm/test/Analysis/MemorySSA/many-dom-backedge.ll b/llvm/test/Analysis/MemorySSA/many-dom-backedge.ll index f16223f2a2c0..d0d14b00e4d1 100644 --- a/llvm/test/Analysis/MemorySSA/many-dom-backedge.ll +++ b/llvm/test/Analysis/MemorySSA/many-dom-backedge.ll @@ -5,7 +5,7 @@ declare i1 @getBool() readnone -define i32 @foo(i32* %p) { +define i32 @foo(ptr %p) { entry: br label %loopbegin @@ -24,42 +24,42 @@ loopbegin: sw.bb: ; CHECK: 1 = MemoryDef(9) ; CHECK-NEXT: store i32 1 - store i32 1, i32* %m, align 4 + store i32 1, ptr %m, align 4 br label %sw.epilog sw.bb1: ; CHECK: 2 = MemoryDef(9) ; CHECK-NEXT: store i32 2 - store i32 2, i32* %m, align 4 + store i32 2, ptr %m, align 4 br label %sw.epilog sw.bb2: ; CHECK: 3 = MemoryDef(9) ; CHECK-NEXT: store i32 3 - store i32 3, i32* %m, align 4 + store i32 3, ptr %m, align 4 br label %sw.epilog sw.bb3: ; CHECK: 10 = MemoryPhi({loopbegin,9},{sw.almostexit,6}) ; CHECK: 4 = MemoryDef(10) ; CHECK-NEXT: store i32 4 - store i32 4, i32* %m, align 4 + store i32 4, ptr %m, align 4 br label %sw.epilog sw.default: ; CHECK: 5 = MemoryDef(9) ; CHECK-NEXT: store i32 5 - store i32 5, i32* %m, align 4 + store i32 5, ptr %m, align 4 br label %sw.epilog sw.epilog: ; CHECK: 8 = MemoryPhi({sw.default,5},{sw.bb3,4},{sw.bb,1},{sw.bb1,2},{sw.bb2,3}) ; CHECK-NEXT: MemoryUse(8) ; CHECK-NEXT: %0 = - %0 = load i32, i32* %m, align 4 + %0 = load i32, ptr %m, align 4 ; CHECK: 6 = MemoryDef(8) ; CHECK-NEXT: %1 = - %1 = load volatile i32, i32* %p, align 4 + %1 = load volatile i32, ptr %p, align 4 %2 = icmp eq i32 %0, %1 br i1 %2, label %sw.almostexit, label %loopbegin @@ -70,7 +70,7 @@ sw.almostexit: exit: ; CHECK: 7 = MemoryDef(6) ; CHECK-NEXT: %4 = load volatile i32 - %4 = load volatile i32, i32* %p, align 4 + %4 = load volatile i32, ptr %p, align 4 %5 = add i32 %4, %1 ret i32 %5 } diff --git a/llvm/test/Analysis/MemorySSA/many-doms.ll b/llvm/test/Analysis/MemorySSA/many-doms.ll index 12126af95311..cdf51f781dac 100644 --- a/llvm/test/Analysis/MemorySSA/many-doms.ll +++ b/llvm/test/Analysis/MemorySSA/many-doms.ll @@ -4,7 +4,7 @@ declare i1 @getBool() readnone -define i32 @foo(i32* %p) { +define i32 @foo(ptr %p) { entry: br label %loopbegin @@ -23,41 +23,41 @@ loopbegin: sw.bb: ; CHECK: 1 = MemoryDef(8) ; CHECK-NEXT: store i32 1 - store i32 1, i32* %m, align 4 + store i32 1, ptr %m, align 4 br label %sw.epilog sw.bb1: ; CHECK: 2 = MemoryDef(8) ; CHECK-NEXT: store i32 2 - store i32 2, i32* %m, align 4 + store i32 2, ptr %m, align 4 br label %sw.epilog sw.bb2: ; CHECK: 3 = MemoryDef(8) ; CHECK-NEXT: store i32 3 - store i32 3, i32* %m, align 4 + store i32 3, ptr %m, align 4 br label %sw.epilog sw.bb3: ; CHECK: 4 = MemoryDef(8) ; CHECK-NEXT: store i32 4 - store i32 4, i32* %m, align 4 + store i32 4, ptr %m, align 4 br label %sw.epilog sw.default: ; CHECK: 5 = MemoryDef(8) ; CHECK-NEXT: store i32 5 - store i32 5, i32* %m, align 4 + store i32 5, ptr %m, align 4 br label %sw.epilog sw.epilog: ; CHECK: 7 = MemoryPhi({sw.default,5},{sw.bb,1},{sw.bb1,2},{sw.bb2,3},{sw.bb3,4}) ; CHECK-NEXT: MemoryUse(7) ; CHECK-NEXT: %0 = - %0 = load i32, i32* %m, align 4 + %0 = load i32, ptr %m, align 4 ; CHECK: 6 = MemoryDef(7) ; CHECK-NEXT: %1 = - %1 = load volatile i32, i32* %p, align 4 + %1 = load volatile i32, ptr %p, align 4 %2 = icmp eq i32 %0, %1 br i1 %2, label %exit, label %loopbegin diff --git a/llvm/test/Analysis/MemorySSA/multi-edges.ll b/llvm/test/Analysis/MemorySSA/multi-edges.ll index 135319721be9..cb76944eaa96 100644 --- a/llvm/test/Analysis/MemorySSA/multi-edges.ll +++ b/llvm/test/Analysis/MemorySSA/multi-edges.ll @@ -8,21 +8,21 @@ entry: %0 = alloca i32, align 4 ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i32 4 - store i32 4, i32* %0 + store i32 4, ptr %0 br i1 %a, label %Loop.Body, label %Loop.End Loop.Body: ; CHECK: 4 = MemoryPhi({entry,1},{Loop.End,3}) ; CHECK-NEXT: 2 = MemoryDef(4) ; CHECK-NEXT: store i32 5 - store i32 5, i32* %0, align 4 + store i32 5, ptr %0, align 4 br i1 %a, label %Loop.End, label %Loop.End ; WhyDoWeEvenHaveThatLever.gif Loop.End: ; CHECK: 3 = MemoryPhi({entry,1},{Loop.Body,2},{Loop.Body,2}) ; CHECK-NEXT: MemoryUse(3) ; CHECK-NEXT: %1 = load - %1 = load i32, i32* %0, align 4 + %1 = load i32, ptr %0, align 4 %2 = icmp eq i32 5, %1 br i1 %2, label %Ret, label %Loop.Body diff --git a/llvm/test/Analysis/MemorySSA/multiple-backedges-hal.ll b/llvm/test/Analysis/MemorySSA/multiple-backedges-hal.ll index 9961e3fc20b3..601d98f06ea4 100644 --- a/llvm/test/Analysis/MemorySSA/multiple-backedges-hal.ll +++ b/llvm/test/Analysis/MemorySSA/multiple-backedges-hal.ll @@ -30,13 +30,13 @@ declare void @doThingWithoutReading() readnone declare i8 @getValue() readnone declare i1 @getBool() readnone -define hidden void @testcase(i8* %Arg) { +define hidden void @testcase(ptr %Arg) { Entry: call void @doThingWithoutReading() %Val.Entry = call i8 @getValue() ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i8 %Val.Entry - store i8 %Val.Entry, i8* %Arg + store i8 %Val.Entry, ptr %Arg call void @doThingWithoutReading() br label %OuterLoop @@ -46,7 +46,7 @@ OuterLoop: %Val.Outer = call i8 @getValue() ; CHECK: 2 = MemoryDef(5) ; CHECK-NEXT: store i8 %Val.Outer - store i8 %Val.Outer, i8* %Arg + store i8 %Val.Outer, ptr %Arg call void @doThingWithoutReading() br label %InnerLoop @@ -54,11 +54,11 @@ InnerLoop: ; CHECK: 4 = MemoryPhi({OuterLoop,2},{InnerLoop,3}) ; CHECK-NEXT: ; MemoryUse(4) ; CHECK-NEXT: %StartingAccess = load - %StartingAccess = load i8, i8* %Arg, align 4 + %StartingAccess = load i8, ptr %Arg, align 4 %Val.Inner = call i8 @getValue() ; CHECK: 3 = MemoryDef(4) ; CHECK-NEXT: store i8 %Val.Inner - store i8 %Val.Inner, i8* %Arg + store i8 %Val.Inner, ptr %Arg call void @doThingWithoutReading() %KeepGoing = call i1 @getBool() br i1 %KeepGoing, label %InnerLoop.Tail, label %InnerLoop diff --git a/llvm/test/Analysis/MemorySSA/multiple-locations.ll b/llvm/test/Analysis/MemorySSA/multiple-locations.ll index 99e818d90de5..0ec05db88ea2 100644 --- a/llvm/test/Analysis/MemorySSA/multiple-locations.ll +++ b/llvm/test/Analysis/MemorySSA/multiple-locations.ll @@ -7,17 +7,17 @@ define i32 @foo(i1 %cond) { %b = alloca i32, align 4 ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i32 0 - store i32 0, i32* %a, align 4 + store i32 0, ptr %a, align 4 ; CHECK: 2 = MemoryDef(1) ; CHECK-NEXT: store i32 1 - store i32 1, i32* %b, align 4 + store i32 1, ptr %b, align 4 ; CHECK: MemoryUse(1) ; CHECK-NEXT: %1 = load i32 - %1 = load i32, i32* %a, align 4 + %1 = load i32, ptr %a, align 4 ; CHECK: MemoryUse(2) ; CHECK-NEXT: %2 = load i32 - %2 = load i32, i32* %b, align 4 + %2 = load i32, ptr %b, align 4 %3 = add i32 %1, %2 ret i32 %3 diff --git a/llvm/test/Analysis/MemorySSA/no-disconnected.ll b/llvm/test/Analysis/MemorySSA/no-disconnected.ll index bf9d5b1b85b6..c56dce689911 100644 --- a/llvm/test/Analysis/MemorySSA/no-disconnected.ll +++ b/llvm/test/Analysis/MemorySSA/no-disconnected.ll @@ -7,36 +7,36 @@ ; entry on each edge, it would choose 2, 4 and disconnect 1 and 3 completely ; from the SSA graph, even though they are not dead -define void @sink_store(i32 %index, i32* %foo, i32* %bar) { +define void @sink_store(i32 %index, ptr %foo, ptr %bar) { entry: %cmp = trunc i32 %index to i1 br i1 %cmp, label %if.then, label %if.else if.then: ; preds = %entry ; CHECK: 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: store i32 %index, i32* %foo, align 4 - store i32 %index, i32* %foo, align 4 +; CHECK-NEXT: store i32 %index, ptr %foo, align 4 + store i32 %index, ptr %foo, align 4 ; CHECK: 2 = MemoryDef(1) -; CHECK-NEXT: store i32 %index, i32* %bar, align 4 - store i32 %index, i32* %bar, align 4 +; CHECK-NEXT: store i32 %index, ptr %bar, align 4 + store i32 %index, ptr %bar, align 4 br label %if.end if.else: ; preds = %entry ; CHECK: 3 = MemoryDef(liveOnEntry) -; CHECK-NEXT: store i32 %index, i32* %foo, align 4 - store i32 %index, i32* %foo, align 4 +; CHECK-NEXT: store i32 %index, ptr %foo, align 4 + store i32 %index, ptr %foo, align 4 ; CHECK: 4 = MemoryDef(3) -; CHECK-NEXT: store i32 %index, i32* %bar, align 4 - store i32 %index, i32* %bar, align 4 +; CHECK-NEXT: store i32 %index, ptr %bar, align 4 + store i32 %index, ptr %bar, align 4 br label %if.end if.end: ; preds = %if.else, %if.then ; CHECK: 5 = MemoryPhi({if.then,2},{if.else,4}) ; CHECK: MemoryUse(5) -; CHECK-NEXT: %c = load i32, i32* %foo - %c = load i32, i32* %foo +; CHECK-NEXT: %c = load i32, ptr %foo + %c = load i32, ptr %foo ; CHECK: MemoryUse(5) -; CHECK-NEXT: %d = load i32, i32* %bar - %d = load i32, i32* %bar +; CHECK-NEXT: %d = load i32, ptr %bar + %d = load i32, ptr %bar ret void } diff --git a/llvm/test/Analysis/MemorySSA/noalias-scope-decl.ll b/llvm/test/Analysis/MemorySSA/noalias-scope-decl.ll index 2517430b814e..c17b78c920ea 100644 --- a/llvm/test/Analysis/MemorySSA/noalias-scope-decl.ll +++ b/llvm/test/Analysis/MemorySSA/noalias-scope-decl.ll @@ -4,16 +4,16 @@ declare void @llvm.experimental.noalias.scope.decl(metadata) -define i32 @foo(i32* %a, i32* %b, i1 %c) { +define i32 @foo(ptr %a, ptr %b, i1 %c) { ; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK-NEXT: store i32 4 - store i32 4, i32* %a, align 4 + store i32 4, ptr %a, align 4 ; CHECK-NOT: MemoryDef ; CHECK: call void @llvm.experimental.noalias.scope.decl call void @llvm.experimental.noalias.scope.decl(metadata !0) ; CHECK: MemoryUse(1) ; CHECK-NEXT: %1 = load i32 - %1 = load i32, i32* %a, align 4 + %1 = load i32, ptr %a, align 4 ret i32 %1 } diff --git a/llvm/test/Analysis/MemorySSA/nondeterminism.ll b/llvm/test/Analysis/MemorySSA/nondeterminism.ll index 230c6e61fb33..b1e3e55d363c 100644 --- a/llvm/test/Analysis/MemorySSA/nondeterminism.ll +++ b/llvm/test/Analysis/MemorySSA/nondeterminism.ll @@ -90,22 +90,22 @@ bb2.split: ; preds = %bb2.bb2.split_crit_ bb4: ; preds = %bb2.split, %bb6 %i.4.01 = phi i16 [ 0, %bb2.split ] - %_tmp16 = getelementptr [1 x [1 x %rec9]], [1 x [1 x %rec9]]* @a, i16 0, i16 %h.3.0, i16 %i.4.01, i32 0 - %_tmp17 = load i16, i16* %_tmp16, align 1 + %_tmp16 = getelementptr [1 x [1 x %rec9]], ptr @a, i16 0, i16 %h.3.0, i16 %i.4.01, i32 0 + %_tmp17 = load i16, ptr %_tmp16, align 1 br label %g.exit4.critedge bb1.i: ; preds = %bb4 br label %g.exit4 g.exit4.critedge: ; preds = %bb4 - %_tmp28.c = getelementptr [1 x [1 x %rec9]], [1 x [1 x %rec9]]* @a, i16 0, i16 %h.3.0, i16 %i.4.01, i32 1 - %_tmp29.c = load i32, i32* %_tmp28.c, align 1 + %_tmp28.c = getelementptr [1 x [1 x %rec9]], ptr @a, i16 0, i16 %h.3.0, i16 %i.4.01, i32 1 + %_tmp29.c = load i32, ptr %_tmp28.c, align 1 %_tmp30.c = trunc i32 %_tmp29.c to i16 br label %g.exit4 g.exit4: ; preds = %g.exit4.critedge, %bb1.i %i.4.02 = phi i16 [ %i.4.01, %g.exit4.critedge ], [ %i.4.01, %bb1.i ] - %_tmp41 = getelementptr [1 x [1 x %rec9]], [1 x [1 x %rec9]]* @a, i16 0, i16 %h.3.0, i16 %i.4.02, i32 2 + %_tmp41 = getelementptr [1 x [1 x %rec9]], ptr @a, i16 0, i16 %h.3.0, i16 %i.4.02, i32 2 br label %bb6 bb5: ; preds = %g.exit4 diff --git a/llvm/test/Analysis/MemorySSA/optimize-use.ll b/llvm/test/Analysis/MemorySSA/optimize-use.ll index e1b529670f30..9db457081dd4 100644 --- a/llvm/test/Analysis/MemorySSA/optimize-use.ll +++ b/llvm/test/Analysis/MemorySSA/optimize-use.ll @@ -5,42 +5,40 @@ define i32 @main() { entry: ; CHECK: 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: %call = call noalias i8* @_Znwm(i64 4) - %call = call noalias i8* @_Znwm(i64 4) - %0 = bitcast i8* %call to i32* +; CHECK-NEXT: %call = call noalias ptr @_Znwm(i64 4) + %call = call noalias ptr @_Znwm(i64 4) ; CHECK: 2 = MemoryDef(1) -; CHECK-NEXT: %call1 = call noalias i8* @_Znwm(i64 4) - %call1 = call noalias i8* @_Znwm(i64 4) - %1 = bitcast i8* %call1 to i32* +; CHECK-NEXT: %call1 = call noalias ptr @_Znwm(i64 4) + %call1 = call noalias ptr @_Znwm(i64 4) ; CHECK: 3 = MemoryDef(2) -; CHECK-NEXT: store i32 5, i32* %0, align 4 - store i32 5, i32* %0, align 4 +; CHECK-NEXT: store i32 5, ptr %call, align 4 + store i32 5, ptr %call, align 4 ; CHECK: 4 = MemoryDef(3) -; CHECK-NEXT: store i32 7, i32* %1, align 4 - store i32 7, i32* %1, align 4 +; CHECK-NEXT: store i32 7, ptr %call1, align 4 + store i32 7, ptr %call1, align 4 ; NOLIMIT: MemoryUse(3) -; NOLIMIT-NEXT: %2 = load i32, i32* %0, align 4 +; NOLIMIT-NEXT: %0 = load i32, ptr %call, align 4 ; LIMIT: MemoryUse(4) -; LIMIT-NEXT: %2 = load i32, i32* %0, align 4 - %2 = load i32, i32* %0, align 4 +; LIMIT-NEXT: %0 = load i32, ptr %call, align 4 + %0 = load i32, ptr %call, align 4 ; NOLIMIT: MemoryUse(4) -; NOLIMIT-NEXT: %3 = load i32, i32* %1, align 4 +; NOLIMIT-NEXT: %1 = load i32, ptr %call1, align 4 ; LIMIT: MemoryUse(4) -; LIMIT-NEXT: %3 = load i32, i32* %1, align 4 - %3 = load i32, i32* %1, align 4 +; LIMIT-NEXT: %1 = load i32, ptr %call1, align 4 + %1 = load i32, ptr %call1, align 4 ; NOLIMIT: MemoryUse(3) -; NOLIMIT-NEXT: %4 = load i32, i32* %0, align 4 +; NOLIMIT-NEXT: %2 = load i32, ptr %call, align 4 ; LIMIT: MemoryUse(4) -; LIMIT-NEXT: %4 = load i32, i32* %0, align 4 - %4 = load i32, i32* %0, align 4 +; LIMIT-NEXT: %2 = load i32, ptr %call, align 4 + %2 = load i32, ptr %call, align 4 ; NOLIMIT: MemoryUse(4) -; NOLIMIT-NEXT: %5 = load i32, i32* %1, align 4 +; NOLIMIT-NEXT: %3 = load i32, ptr %call1, align 4 ; LIMIT: MemoryUse(4) -; LIMIT-NEXT: %5 = load i32, i32* %1, align 4 - %5 = load i32, i32* %1, align 4 - %add = add nsw i32 %3, %5 +; LIMIT-NEXT: %3 = load i32, ptr %call1, align 4 + %3 = load i32, ptr %call1, align 4 + %add = add nsw i32 %1, %3 ret i32 %add } -declare noalias i8* @_Znwm(i64) +declare noalias ptr @_Znwm(i64) diff --git a/llvm/test/Analysis/MemorySSA/phi-translation.ll b/llvm/test/Analysis/MemorySSA/phi-translation.ll index 7d5486b7e039..46a49d496573 100644 --- a/llvm/test/Analysis/MemorySSA/phi-translation.ll +++ b/llvm/test/Analysis/MemorySSA/phi-translation.ll @@ -4,28 +4,28 @@ ; %ptr can't alias %local, so we should be able to optimize the use of %local to ; point to the store to %local. ; CHECK-LABEL: define void @check -define void @check(i8* %ptr, i1 %bool) { +define void @check(ptr %ptr, i1 %bool) { entry: %local = alloca i8, align 1 ; CHECK: 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: store i8 0, i8* %local, align 1 - store i8 0, i8* %local, align 1 +; CHECK-NEXT: store i8 0, ptr %local, align 1 + store i8 0, ptr %local, align 1 br i1 %bool, label %if.then, label %if.end if.then: - %p2 = getelementptr inbounds i8, i8* %ptr, i32 1 + %p2 = getelementptr inbounds i8, ptr %ptr, i32 1 ; CHECK: 2 = MemoryDef(1) -; CHECK-NEXT: store i8 0, i8* %p2, align 1 - store i8 0, i8* %p2, align 1 +; CHECK-NEXT: store i8 0, ptr %p2, align 1 + store i8 0, ptr %p2, align 1 br label %if.end if.end: ; CHECK: 3 = MemoryPhi({entry,1},{if.then,2}) ; NOLIMIT: MemoryUse(1) -; NOLIMIT-NEXT: load i8, i8* %local, align 1 +; NOLIMIT-NEXT: load i8, ptr %local, align 1 ; LIMIT: MemoryUse(3) -; LIMIT-NEXT: load i8, i8* %local, align 1 - load i8, i8* %local, align 1 +; LIMIT-NEXT: load i8, ptr %local, align 1 + load i8, ptr %local, align 1 ret void } @@ -36,28 +36,28 @@ entry: %local2 = alloca i8, align 1 ; CHECK: 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: store i8 0, i8* %local - store i8 0, i8* %local +; CHECK-NEXT: store i8 0, ptr %local + store i8 0, ptr %local br i1 %val1, label %if.then, label %phi.3 if.then: ; CHECK: 2 = MemoryDef(1) -; CHECK-NEXT: store i8 2, i8* %local2 - store i8 2, i8* %local2 +; CHECK-NEXT: store i8 2, ptr %local2 + store i8 2, ptr %local2 br i1 %val2, label %phi.2, label %phi.3 phi.3: ; CHECK: 7 = MemoryPhi({entry,1},{if.then,2}) ; CHECK: 3 = MemoryDef(7) -; CHECK-NEXT: store i8 3, i8* %local2 - store i8 3, i8* %local2 +; CHECK-NEXT: store i8 3, ptr %local2 + store i8 3, ptr %local2 br i1 %val3, label %phi.2, label %phi.1 phi.2: ; CHECK: 5 = MemoryPhi({if.then,2},{phi.3,3}) ; CHECK: 4 = MemoryDef(5) -; CHECK-NEXT: store i8 4, i8* %local2 - store i8 4, i8* %local2 +; CHECK-NEXT: store i8 4, ptr %local2 + store i8 4, ptr %local2 br label %phi.1 phi.1: @@ -65,97 +65,97 @@ phi.1: ; they're visited in. ; CHECK: 6 = MemoryPhi({phi.2,4},{phi.3,3}) ; NOLIMIT: MemoryUse(1) -; NOLIMIT-NEXT: load i8, i8* %local +; NOLIMIT-NEXT: load i8, ptr %local ; LIMIT: MemoryUse(6) -; LIMIT-NEXT: load i8, i8* %local - load i8, i8* %local +; LIMIT-NEXT: load i8, ptr %local + load i8, ptr %local ret void } ; CHECK-LABEL: define void @cross_phi -define void @cross_phi(i8* noalias %p1, i8* noalias %p2) { +define void @cross_phi(ptr noalias %p1, ptr noalias %p2) { ; CHECK: 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: store i8 0, i8* %p1 - store i8 0, i8* %p1 +; CHECK-NEXT: store i8 0, ptr %p1 + store i8 0, ptr %p1 ; NOLIMIT: MemoryUse(1) -; NOLIMIT-NEXT: load i8, i8* %p1 +; NOLIMIT-NEXT: load i8, ptr %p1 ; LIMIT: MemoryUse(1) -; LIMIT-NEXT: load i8, i8* %p1 - load i8, i8* %p1 +; LIMIT-NEXT: load i8, ptr %p1 + load i8, ptr %p1 br i1 undef, label %a, label %b a: ; CHECK: 2 = MemoryDef(1) -; CHECK-NEXT: store i8 0, i8* %p2 - store i8 0, i8* %p2 +; CHECK-NEXT: store i8 0, ptr %p2 + store i8 0, ptr %p2 br i1 undef, label %c, label %d b: ; CHECK: 3 = MemoryDef(1) -; CHECK-NEXT: store i8 1, i8* %p2 - store i8 1, i8* %p2 +; CHECK-NEXT: store i8 1, ptr %p2 + store i8 1, ptr %p2 br i1 undef, label %c, label %d c: ; CHECK: 6 = MemoryPhi({a,2},{b,3}) ; CHECK: 4 = MemoryDef(6) -; CHECK-NEXT: store i8 2, i8* %p2 - store i8 2, i8* %p2 +; CHECK-NEXT: store i8 2, ptr %p2 + store i8 2, ptr %p2 br label %e d: ; CHECK: 7 = MemoryPhi({a,2},{b,3}) ; CHECK: 5 = MemoryDef(7) -; CHECK-NEXT: store i8 3, i8* %p2 - store i8 3, i8* %p2 +; CHECK-NEXT: store i8 3, ptr %p2 + store i8 3, ptr %p2 br label %e e: ; 8 = MemoryPhi({c,4},{d,5}) ; NOLIMIT: MemoryUse(1) -; NOLIMIT-NEXT: load i8, i8* %p1 +; NOLIMIT-NEXT: load i8, ptr %p1 ; LIMIT: MemoryUse(8) -; LIMIT-NEXT: load i8, i8* %p1 - load i8, i8* %p1 +; LIMIT-NEXT: load i8, ptr %p1 + load i8, ptr %p1 ret void } ; CHECK-LABEL: define void @looped -define void @looped(i8* noalias %p1, i8* noalias %p2) { +define void @looped(ptr noalias %p1, ptr noalias %p2) { ; CHECK: 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: store i8 0, i8* %p1 - store i8 0, i8* %p1 +; CHECK-NEXT: store i8 0, ptr %p1 + store i8 0, ptr %p1 br label %loop.1 loop.1: ; CHECK: 6 = MemoryPhi({%0,1},{loop.3,4}) ; CHECK: 2 = MemoryDef(6) -; CHECK-NEXT: store i8 0, i8* %p2 - store i8 0, i8* %p2 +; CHECK-NEXT: store i8 0, ptr %p2 + store i8 0, ptr %p2 br i1 undef, label %loop.2, label %loop.3 loop.2: ; CHECK: 5 = MemoryPhi({loop.1,2},{loop.3,4}) ; CHECK: 3 = MemoryDef(5) -; CHECK-NEXT: store i8 1, i8* %p2 - store i8 1, i8* %p2 +; CHECK-NEXT: store i8 1, ptr %p2 + store i8 1, ptr %p2 br label %loop.3 loop.3: ; CHECK: 7 = MemoryPhi({loop.1,2},{loop.2,3}) ; CHECK: 4 = MemoryDef(7) -; CHECK-NEXT: store i8 2, i8* %p2 - store i8 2, i8* %p2 +; CHECK-NEXT: store i8 2, ptr %p2 + store i8 2, ptr %p2 ; NOLIMIT: MemoryUse(1) -; NOLIMIT-NEXT: load i8, i8* %p1 +; NOLIMIT-NEXT: load i8, ptr %p1 ; LIMIT: MemoryUse(4) -; LIMIT-NEXT: load i8, i8* %p1 - load i8, i8* %p1 +; LIMIT-NEXT: load i8, ptr %p1 + load i8, ptr %p1 br i1 undef, label %loop.2, label %loop.1 } ; CHECK-LABEL: define void @looped_visitedonlyonce -define void @looped_visitedonlyonce(i8* noalias %p1, i8* noalias %p2) { +define void @looped_visitedonlyonce(ptr noalias %p1, ptr noalias %p2) { br label %while.cond while.cond: @@ -165,38 +165,38 @@ while.cond: if.then: ; CHECK: 1 = MemoryDef(5) -; CHECK-NEXT: store i8 0, i8* %p1 - store i8 0, i8* %p1 +; CHECK-NEXT: store i8 0, ptr %p1 + store i8 0, ptr %p1 br i1 undef, label %if.end, label %if.then2 if.then2: ; CHECK: 2 = MemoryDef(1) -; CHECK-NEXT: store i8 1, i8* %p2 - store i8 1, i8* %p2 +; CHECK-NEXT: store i8 1, ptr %p2 + store i8 1, ptr %p2 br label %if.end if.end: ; CHECK: 4 = MemoryPhi({while.cond,5},{if.then,1},{if.then2,2}) ; CHECK: MemoryUse(4) -; CHECK-NEXT: load i8, i8* %p1 - load i8, i8* %p1 +; CHECK-NEXT: load i8, ptr %p1 + load i8, ptr %p1 ; CHECK: 3 = MemoryDef(4) -; CHECK-NEXT: store i8 2, i8* %p2 - store i8 2, i8* %p2 +; CHECK-NEXT: store i8 2, ptr %p2 + store i8 2, ptr %p2 ; NOLIMIT: MemoryUse(4) -; NOLIMIT-NEXT: load i8, i8* %p1 +; NOLIMIT-NEXT: load i8, ptr %p1 ; LIMIT: MemoryUse(3) -; LIMIT-NEXT: load i8, i8* %p1 - load i8, i8* %p1 +; LIMIT-NEXT: load i8, ptr %p1 + load i8, ptr %p1 br label %while.cond } ; CHECK-LABEL: define i32 @use_not_optimized_due_to_backedge -define i32 @use_not_optimized_due_to_backedge(i32* nocapture %m_i_strides, i32* nocapture readonly %eval_left_dims) { +define i32 @use_not_optimized_due_to_backedge(ptr nocapture %m_i_strides, ptr nocapture readonly %eval_left_dims) { entry: ; CHECK: 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: store i32 1, i32* %m_i_strides, align 4 - store i32 1, i32* %m_i_strides, align 4 +; CHECK-NEXT: store i32 1, ptr %m_i_strides, align 4 + store i32 1, ptr %m_i_strides, align 4 br label %for.body for.cond.cleanup: ; preds = %for.inc @@ -209,22 +209,22 @@ for.body: ; preds = %entry, %for.inc %m_i_size.022 = phi i32 [ 1, %entry ], [ %m_i_size.1, %for.inc ] %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 %cmp1 = icmp eq i64 %indvars.iv, 0 - %arrayidx2 = getelementptr inbounds i32, i32* %m_i_strides, i64 %indvars.iv + %arrayidx2 = getelementptr inbounds i32, ptr %m_i_strides, i64 %indvars.iv ; CHECK: MemoryUse(4) -; CHECK-NEXT: %0 = load i32, i32* %arrayidx2, align 4 - %0 = load i32, i32* %arrayidx2, align 4 - %arrayidx4 = getelementptr inbounds i32, i32* %eval_left_dims, i64 %indvars.iv +; CHECK-NEXT: %0 = load i32, ptr %arrayidx2, align 4 + %0 = load i32, ptr %arrayidx2, align 4 + %arrayidx4 = getelementptr inbounds i32, ptr %eval_left_dims, i64 %indvars.iv ; CHECK: MemoryUse(4) -; CHECK-NEXT: %1 = load i32, i32* %arrayidx4, align 4 - %1 = load i32, i32* %arrayidx4, align 4 +; CHECK-NEXT: %1 = load i32, ptr %arrayidx4, align 4 + %1 = load i32, ptr %arrayidx4, align 4 %mul = mul nsw i32 %1, %0 br i1 %cmp1, label %if.then, label %for.inc if.then: ; preds = %for.body - %arrayidx7 = getelementptr inbounds i32, i32* %m_i_strides, i64 %indvars.iv.next + %arrayidx7 = getelementptr inbounds i32, ptr %m_i_strides, i64 %indvars.iv.next ; CHECK: 2 = MemoryDef(4) -; CHECK-NEXT: store i32 %mul, i32* %arrayidx7, align 4 - store i32 %mul, i32* %arrayidx7, align 4 +; CHECK-NEXT: store i32 %mul, ptr %arrayidx7, align 4 + store i32 %mul, ptr %arrayidx7, align 4 br label %for.inc for.inc: ; preds = %for.body, %if.then @@ -240,25 +240,23 @@ for.inc: ; preds = %for.body, %if.then %BigStruct = type { i8, i8, i8, i8, i8, i8, i8, %ArrayType, %ArrayType} ; CHECK-LABEL: define void @use_not_optimized_due_to_backedge_unknown -define void @use_not_optimized_due_to_backedge_unknown(%BigStruct* %this) { +define void @use_not_optimized_due_to_backedge_unknown(ptr %this) { entry: %eval_left_dims = alloca %StructOverArrayType, align 8 - %tmp0 = bitcast %StructOverArrayType* %eval_left_dims to i8* %eval_right_dims = alloca %StructOverArrayType, align 8 - %tmp1 = bitcast %StructOverArrayType* %eval_right_dims to i8* %lhs_strides = alloca %ArrayType, align 8 %rhs_strides = alloca %ArrayType, align 8 br label %for.body.preheader for.body.preheader: ; preds = %entry - %arrayidx.i527 = getelementptr inbounds %BigStruct, %BigStruct* %this, i64 0, i32 7, i32 0, i64 0 + %arrayidx.i527 = getelementptr inbounds %BigStruct, ptr %this, i64 0, i32 7, i32 0, i64 0 ; CHECK: 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: store i64 1, i64* %arrayidx.i527, align 8 - store i64 1, i64* %arrayidx.i527, align 8 - %arrayidx.i528 = getelementptr inbounds %BigStruct, %BigStruct* %this, i64 0, i32 8, i32 0, i64 0 +; CHECK-NEXT: store i64 1, ptr %arrayidx.i527, align 8 + store i64 1, ptr %arrayidx.i527, align 8 + %arrayidx.i528 = getelementptr inbounds %BigStruct, ptr %this, i64 0, i32 8, i32 0, i64 0 ; CHECK: 2 = MemoryDef(1) -; CHECK-NEXT: store i64 1, i64* %arrayidx.i528, align 8 - store i64 1, i64* %arrayidx.i528, align 8 +; CHECK-NEXT: store i64 1, ptr %arrayidx.i528, align 8 + store i64 1, ptr %arrayidx.i528, align 8 br label %for.main.body for.main.body: ; preds = %if.end220.if.then185_crit_edge, %for.body.preheader @@ -267,18 +265,18 @@ for.main.body: ; preds = %if.end220.if.then185_crit_edge, %for.bod %nocontract_idx.0656 = phi i64 [ 0, %for.body.preheader ], [ 1, %if.end220.if.then185_crit_edge ] %add199 = add nuw nsw i64 %nocontract_idx.0656, 1 %cmp200 = icmp eq i64 %nocontract_idx.0656, 0 - %arrayidx.i559 = getelementptr inbounds %BigStruct, %BigStruct* %this, i64 0, i32 7, i32 0, i64 %nocontract_idx.0656 + %arrayidx.i559 = getelementptr inbounds %BigStruct, ptr %this, i64 0, i32 7, i32 0, i64 %nocontract_idx.0656 ; CHECK: MemoryUse(4) -; CHECK-NEXT: %tmp21 = load i64, i64* %arrayidx.i559, align 8 - %tmp21 = load i64, i64* %arrayidx.i559, align 8 +; CHECK-NEXT: %tmp21 = load i64, ptr %arrayidx.i559, align 8 + %tmp21 = load i64, ptr %arrayidx.i559, align 8 %mul206 = mul nsw i64 %tmp21, %tmp21 br i1 %cmp200, label %if.end220.if.then185_crit_edge, label %the.end if.end220.if.then185_crit_edge: ; preds = %for.main.body - %arrayidx.i571 = getelementptr inbounds %BigStruct, %BigStruct* %this, i64 0, i32 7, i32 0, i64 %add199 + %arrayidx.i571 = getelementptr inbounds %BigStruct, ptr %this, i64 0, i32 7, i32 0, i64 %add199 ; CHECK: 3 = MemoryDef(4) -; CHECK-NEXT: store i64 %mul206, i64* %arrayidx.i571, align 8 - store i64 %mul206, i64* %arrayidx.i571, align 8 +; CHECK-NEXT: store i64 %mul206, ptr %arrayidx.i571, align 8 + store i64 %mul206, ptr %arrayidx.i571, align 8 br label %for.main.body the.end: ; preds = %for.main.body @@ -289,74 +287,71 @@ the.end: ; preds = %for.main.body @c = local_unnamed_addr global [2 x i16] zeroinitializer, align 2 -define i32 @dont_merge_noalias_simple(i32* noalias %ptr) { +define i32 @dont_merge_noalias_simple(ptr noalias %ptr) { ; CHECK-LABEL: define i32 @dont_merge_noalias_simple ; CHECK-LABEL: entry: ; CHECK: ; 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: store i16 1, i16* %s1.ptr, align 2 +; CHECK-NEXT: store i16 1, ptr @c, align 2 ; CHECK-LABEL: %for.body ; NOLIMIT: ; MemoryUse(1) ; LIMIT: ; MemoryUse(4) -; CHECK-NEXT: %lv = load i16, i16* %arrayidx, align 2 +; CHECK-NEXT: %lv = load i16, ptr %arrayidx, align 2 entry: - %s1.ptr = getelementptr inbounds [2 x i16], [2 x i16]* @c, i64 0, i64 0 - store i16 1, i16* %s1.ptr, align 2 + store i16 1, ptr @c, align 2 br label %for.body for.body: ; preds = %for.body, %entry %storemerge2 = phi i32 [ 1, %entry ], [ %dec, %for.body ] %idxprom1 = zext i32 %storemerge2 to i64 - %arrayidx = getelementptr inbounds [2 x i16], [2 x i16]* @c, i64 0, i64 %idxprom1 - %lv = load i16, i16* %arrayidx, align 2 + %arrayidx = getelementptr inbounds [2 x i16], ptr @c, i64 0, i64 %idxprom1 + %lv = load i16, ptr %arrayidx, align 2 %conv = sext i16 %lv to i32 - store i32 %conv, i32* %ptr, align 4 + store i32 %conv, ptr %ptr, align 4 %dec = add nsw i32 %storemerge2, -1 %cmp = icmp sgt i32 %storemerge2, 0 br i1 %cmp, label %for.body, label %for.end for.end: ; preds = %for.body - %s2.ptr = getelementptr inbounds [2 x i16], [2 x i16]* @c, i64 0, i64 0 - store i16 0, i16* %s2.ptr, align 2 + store i16 0, ptr @c, align 2 ret i32 0 } -define i32 @dont_merge_noalias_complex(i32* noalias %ptr, i32* noalias %another) { +define i32 @dont_merge_noalias_complex(ptr noalias %ptr, ptr noalias %another) { ; CHECK-LABEL: define i32 @dont_merge_noalias_complex ; CHECK-LABEL: entry: ; CHECK: ; 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: store i16 1, i16* %s1.ptr, align 2 +; CHECK-NEXT: store i16 1, ptr @c, align 2 ; CHECK-LABEL: %for.body ; NOLIMIT: ; MemoryUse(1) ; LIMIT: ; MemoryUse(7) -; CHECK-NEXT: %lv = load i16, i16* %arrayidx, align 2 +; CHECK-NEXT: %lv = load i16, ptr %arrayidx, align 2 entry: - %s1.ptr = getelementptr inbounds [2 x i16], [2 x i16]* @c, i64 0, i64 0 - store i16 1, i16* %s1.ptr, align 2 + store i16 1, ptr @c, align 2 br label %for.body for.body: ; preds = %for.body, %entry %storemerge2 = phi i32 [ 1, %entry ], [ %dec, %merge.body ] %idxprom1 = zext i32 %storemerge2 to i64 - %arrayidx = getelementptr inbounds [2 x i16], [2 x i16]* @c, i64 0, i64 %idxprom1 - %lv = load i16, i16* %arrayidx, align 2 + %arrayidx = getelementptr inbounds [2 x i16], ptr @c, i64 0, i64 %idxprom1 + %lv = load i16, ptr %arrayidx, align 2 %conv = sext i16 %lv to i32 - store i32 %conv, i32* %ptr, align 4 + store i32 %conv, ptr %ptr, align 4 %dec = add nsw i32 %storemerge2, -1 %cmpif = icmp sgt i32 %storemerge2, 1 br i1 %cmpif, label %if.body, label %else.body if.body: - store i32 %conv, i32* %another, align 4 + store i32 %conv, ptr %another, align 4 br label %merge.body else.body: - store i32 %conv, i32* %another, align 4 + store i32 %conv, ptr %another, align 4 br label %merge.body merge.body: @@ -364,16 +359,15 @@ merge.body: br i1 %cmp, label %for.body, label %for.end for.end: ; preds = %for.body - %s2.ptr = getelementptr inbounds [2 x i16], [2 x i16]* @c, i64 0, i64 0 - store i16 0, i16* %s2.ptr, align 2 + store i16 0, ptr @c, align 2 ret i32 0 } declare i1 @should_exit(i32) readnone -declare void @init([32 x i32]*) +declare void @init(ptr) ; Test case for PR47498. -; %l.1 may read the result of `store i32 10, i32* %p.1` in %storebb, because +; %l.1 may read the result of `store i32 10, ptr %p.1` in %storebb, because ; after %storebb has been executed, %loop.1.header might be executed again. ; Make sure %l.1's defining access is the MemoryPhi in the block. define void @dont_merge_noalias_complex_2(i32 %arg, i32 %arg1) { @@ -381,33 +375,33 @@ define void @dont_merge_noalias_complex_2(i32 %arg, i32 %arg1) { ; CHECK-LABEL: entry: ; CHECK: ; 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: call void @init([32 x i32]* %tmp) +; CHECK-NEXT: call void @init(ptr %tmp) ; CHECK-LABEL: loop.1.header: ; CHECK-NEXT: ; 4 = MemoryPhi({entry,1},{loop.1.latch,3}) ; CHECK: ; MemoryUse(4) -; CHECK-NEXT: %l.1 = load i32, i32* %p.1, align 4 +; CHECK-NEXT: %l.1 = load i32, ptr %p.1, align 4 ; CHECK-LABEL: loop.1.latch: ; CHECK-NEXT: ; 3 = MemoryPhi({loop.1.header,4},{storebb,2}) ; CHECK-LABEL: storebb: ; CHECK-NEXT: %iv.add2 = add nuw nsw i64 %iv, 2 -; CHECK-NEXT: %p.2 = getelementptr inbounds [32 x i32], [32 x i32]* %tmp, i64 0, i64 %iv.add2 +; CHECK-NEXT: %p.2 = getelementptr inbounds [32 x i32], ptr %tmp, i64 0, i64 %iv.add2 ; CHECK-NEXT: ; MemoryUse(4) -; CHECK-NEXT: %l.2 = load i32, i32* %p.2, align 4 +; CHECK-NEXT: %l.2 = load i32, ptr %p.2, align 4 ; CHECK-NEXT: ; 2 = MemoryDef(4) -; CHECK-NEXT: store i32 10, i32* %p.1, align 4 +; CHECK-NEXT: store i32 10, ptr %p.1, align 4 entry: %tmp = alloca [32 x i32], align 16 - call void @init([32 x i32]* %tmp) + call void @init(ptr %tmp) br label %loop.1.header loop.1.header: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop.1.latch ] %iv.next = add nuw nsw i64 %iv, 1 - %p.1 = getelementptr inbounds [32 x i32], [32 x i32]* %tmp, i64 0, i64 %iv.next - %l.1 = load i32, i32* %p.1, align 4 + %p.1 = getelementptr inbounds [32 x i32], ptr %tmp, i64 0, i64 %iv.next + %l.1 = load i32, ptr %p.1, align 4 %tmp244 = icmp ult i64 %iv, 10 br i1 %tmp244, label %loop.1.latch, label %storebb @@ -417,9 +411,9 @@ loop.1.latch: storebb: %iv.add2 = add nuw nsw i64 %iv, 2 - %p.2 = getelementptr inbounds [32 x i32], [32 x i32]* %tmp, i64 0, i64 %iv.add2 - %l.2 = load i32, i32* %p.2, align 4 - store i32 10, i32* %p.1, align 4 + %p.2 = getelementptr inbounds [32 x i32], ptr %tmp, i64 0, i64 %iv.add2 + %l.2 = load i32, ptr %p.2, align 4 + store i32 10, ptr %p.1, align 4 br label %loop.1.latch exit: @@ -430,38 +424,37 @@ define i32 @phi_with_constant_values(i1 %cmp) { ; CHECK-LABEL: define i32 @phi_with_constant_values ; CHECK-LABEL: lhs: ; CHECK: ; 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: store i16 1, i16* %s1.ptr, align 2 +; CHECK-NEXT: store i16 1, ptr @c, align 2 ; CHECK-LABEL: rhs: ; CHECK: ; 2 = MemoryDef(liveOnEntry) -; CHECK-NEXT: store i16 1, i16* %s2.ptr, align 2 +; CHECK-NEXT: store i16 1, ptr %s2.ptr, align 2 ; CHECK-LABEL: merge: ; CHECK: ; 3 = MemoryPhi({lhs,1},{rhs,2}) ; CHECK-NEXT %storemerge2 = phi i32 [ 2, %lhs ], [ 3, %rhs ] ; LIMIT: ; MemoryUse(3) -; LIMIT-NEXT: %lv = load i16, i16* %arrayidx, align 2 +; LIMIT-NEXT: %lv = load i16, ptr %arrayidx, align 2 ; NOLIMIT: ; MemoryUse(liveOnEntry) -; NOLIMIT-NEXT: %lv = load i16, i16* %arrayidx, align 2 +; NOLIMIT-NEXT: %lv = load i16, ptr %arrayidx, align 2 entry: br i1 %cmp, label %lhs, label %rhs lhs: - %s1.ptr = getelementptr inbounds [2 x i16], [2 x i16]* @c, i64 0, i64 0 - store i16 1, i16* %s1.ptr, align 2 + store i16 1, ptr @c, align 2 br label %merge rhs: - %s2.ptr = getelementptr inbounds [2 x i16], [2 x i16]* @c, i64 0, i64 1 - store i16 1, i16* %s2.ptr, align 2 + %s2.ptr = getelementptr inbounds [2 x i16], ptr @c, i64 0, i64 1 + store i16 1, ptr %s2.ptr, align 2 br label %merge merge: ; preds = %for.body, %entry %storemerge2 = phi i32 [ 2, %lhs ], [ 3, %rhs ] %idxprom1 = zext i32 %storemerge2 to i64 - %arrayidx = getelementptr inbounds [2 x i16], [2 x i16]* @c, i64 0, i64 %idxprom1 - %lv = load i16, i16* %arrayidx, align 2 + %arrayidx = getelementptr inbounds [2 x i16], ptr @c, i64 0, i64 %idxprom1 + %lv = load i16, ptr %arrayidx, align 2 br label %end end: ; preds = %for.body @@ -472,8 +465,7 @@ end: ; preds = %for.body define void @use_clobbered_by_def_in_loop() { entry: %nodeStack = alloca [12 x i32], align 4 - %0 = bitcast [12 x i32]* %nodeStack to i8* - call void @llvm.lifetime.start.p0i8(i64 48, i8* nonnull %0) + call void @llvm.lifetime.start.p0(i64 48, ptr nonnull %nodeStack) br i1 false, label %cleanup, label %while.cond ; CHECK-LABEL: while.cond: @@ -486,14 +478,14 @@ while.cond: ; preds = %entry, %while.cond. ; CHECK-LABEL: land.rhs: ; CHECK-NEXT: %sub = add nsw i32 %depth.1, -1 -; CHECK-NEXT: %arrayidx = getelementptr inbounds [12 x i32], [12 x i32]* %nodeStack, i32 0, i32 %sub +; CHECK-NEXT: %arrayidx = getelementptr inbounds [12 x i32], ptr %nodeStack, i32 0, i32 %sub ; CHECK-NEXT: ; MemoryUse([[NO6]]) -; CHECK-NEXT: %1 = load i32, i32* %arrayidx, align 4 +; CHECK-NEXT: %0 = load i32, ptr %arrayidx, align 4 land.rhs: ; preds = %while.cond %sub = add nsw i32 %depth.1, -1 - %arrayidx = getelementptr inbounds [12 x i32], [12 x i32]* %nodeStack, i32 0, i32 %sub - %1 = load i32, i32* %arrayidx, align 4 + %arrayidx = getelementptr inbounds [12 x i32], ptr %nodeStack, i32 0, i32 %sub + %0 = load i32, ptr %arrayidx, align 4 br i1 true, label %while.body, label %while.end while.body: ; preds = %land.rhs @@ -504,18 +496,18 @@ while.cond.backedge: ; preds = %while.body, %while. br label %while.cond while.end: ; preds = %while.cond, %land.rhs - %arrayidx10 = getelementptr inbounds [12 x i32], [12 x i32]* %nodeStack, i32 0, i32 %depth.1 - store i32 %depth.1, i32* %arrayidx10, align 4 + %arrayidx10 = getelementptr inbounds [12 x i32], ptr %nodeStack, i32 0, i32 %depth.1 + store i32 %depth.1, ptr %arrayidx10, align 4 %inc = add nsw i32 %depth.1, 1 br i1 true, label %cleanup, label %while.cond.backedge cleanup: ; preds = %while.body, %while.end, %entry - call void @llvm.lifetime.end.p0i8(i64 48, i8* nonnull %0) + call void @llvm.lifetime.end.p0(i64 48, ptr nonnull %nodeStack) ret void } -declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) -declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) +declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) +declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) define void @another_loop_clobber_inc() { ; CHECK-LABEL: void @another_loop_clobber_inc @@ -524,12 +516,12 @@ define void @another_loop_clobber_inc() { ; CHECK-LABEL: cond.read: ; CHECK: ; MemoryUse(4) -; CHECK-NEXT: %use = load i32, i32* %ptr.1, align 4 +; CHECK-NEXT: %use = load i32, ptr %ptr.1, align 4 ; CHECK-NEXT: ; 2 = MemoryDef(4) ; CHECK-NEXT: %c.2 = call i1 @cond(i32 %use) -; CHECK-NEXT: %ptr.10 = getelementptr inbounds [12 x i32], [12 x i32]* %nodeStack, i32 0, i32 %inc +; CHECK-NEXT: %ptr.10 = getelementptr inbounds [12 x i32], ptr %nodeStack, i32 0, i32 %inc ; CHECK-NEXT: ; 3 = MemoryDef(2) -; CHECK-NEXT: store i32 10, i32* %ptr.2, align 4 +; CHECK-NEXT: store i32 10, ptr %ptr.2, align 4 entry: %nodeStack = alloca [12 x i32], align 4 @@ -544,12 +536,12 @@ loop.header: ; preds = %entry, %while.cond br i1 %cmp, label %cond.read, label %cleanup cond.read: ; preds = %while.cond - %ptr.1 = getelementptr inbounds [12 x i32], [12 x i32]* %nodeStack, i32 0, i32 %depth.1 - %ptr.2 = getelementptr inbounds [12 x i32], [12 x i32]* %nodeStack, i32 0, i32 %inc2 - %use = load i32, i32* %ptr.1, align 4 + %ptr.1 = getelementptr inbounds [12 x i32], ptr %nodeStack, i32 0, i32 %depth.1 + %ptr.2 = getelementptr inbounds [12 x i32], ptr %nodeStack, i32 0, i32 %inc2 + %use = load i32, ptr %ptr.1, align 4 %c.2 = call i1 @cond(i32 %use) - %ptr.10 = getelementptr inbounds [12 x i32], [12 x i32]* %nodeStack, i32 0, i32 %inc - store i32 10, i32* %ptr.2, align 4 + %ptr.10 = getelementptr inbounds [12 x i32], ptr %nodeStack, i32 0, i32 %inc + store i32 10, ptr %ptr.2, align 4 br i1 %c.2, label %loop.header, label %cleanup cleanup: @@ -563,12 +555,12 @@ define void @another_loop_clobber_dec() { ; CHECK-LABEL: cond.read: ; CHECK: ; MemoryUse(4) -; CHECK-NEXT: %use = load i32, i32* %ptr.1, align 4 +; CHECK-NEXT: %use = load i32, ptr %ptr.1, align 4 ; CHECK-NEXT: ; 2 = MemoryDef(4) ; CHECK-NEXT: %c.2 = call i1 @cond(i32 %use) -; CHECK-NEXT: %ptr.10 = getelementptr inbounds [12 x i32], [12 x i32]* %nodeStack, i32 0, i64 %sub +; CHECK-NEXT: %ptr.10 = getelementptr inbounds [12 x i32], ptr %nodeStack, i32 0, i64 %sub ; CHECK-NEXT: ; 3 = MemoryDef(2) -; CHECK-NEXT: store i32 10, i32* %ptr.2, align 4 +; CHECK-NEXT: store i32 10, ptr %ptr.2, align 4 entry: %nodeStack = alloca [12 x i32], align 4 @@ -583,12 +575,12 @@ loop.header: ; preds = %entry, %while.cond br i1 %cmp, label %cond.read, label %cleanup cond.read: ; preds = %while.cond - %ptr.1 = getelementptr inbounds [12 x i32], [12 x i32]* %nodeStack, i32 0, i64 %depth.1 - %ptr.2 = getelementptr inbounds [12 x i32], [12 x i32]* %nodeStack, i32 0, i64 %sub2 - %use = load i32, i32* %ptr.1, align 4 + %ptr.1 = getelementptr inbounds [12 x i32], ptr %nodeStack, i32 0, i64 %depth.1 + %ptr.2 = getelementptr inbounds [12 x i32], ptr %nodeStack, i32 0, i64 %sub2 + %use = load i32, ptr %ptr.1, align 4 %c.2 = call i1 @cond(i32 %use) - %ptr.10 = getelementptr inbounds [12 x i32], [12 x i32]* %nodeStack, i32 0, i64 %sub - store i32 10, i32* %ptr.2, align 4 + %ptr.10 = getelementptr inbounds [12 x i32], ptr %nodeStack, i32 0, i64 %sub + store i32 10, ptr %ptr.2, align 4 br i1 %c.2, label %loop.header, label %cleanup cleanup: diff --git a/llvm/test/Analysis/MemorySSA/pr28880.ll b/llvm/test/Analysis/MemorySSA/pr28880.ll index b7349655faf9..57cdab792040 100644 --- a/llvm/test/Analysis/MemorySSA/pr28880.ll +++ b/llvm/test/Analysis/MemorySSA/pr28880.ll @@ -16,12 +16,12 @@ bb1: ; preds = %bb ; These accesses should not conflict. ; CHECK: 1 = MemoryDef(liveOnEntry) ; 1 = MemoryDef(liveOnEntry) -; CHECK-NEXT: store double undef, double* @global, align 8 - store double undef, double* @global, align 8 +; CHECK-NEXT: store double undef, ptr @global, align 8 + store double undef, ptr @global, align 8 ; CHECK: MemoryUse(liveOnEntry) ; MemoryUse(liveOnEntry) -; CHECK-NEXT: %tmp = load double, double* @global.1, align 8 - %tmp = load double, double* @global.1, align 8 +; CHECK-NEXT: %tmp = load double, ptr @global.1, align 8 + %tmp = load double, ptr @global.1, align 8 unreachable bb2: ; preds = %bb @@ -34,12 +34,12 @@ bb4: ; preds = %bb3 ; These accesses should conflict. ; CHECK: 2 = MemoryDef(liveOnEntry) ; 2 = MemoryDef(liveOnEntry) -; CHECK-NEXT: store double 0.000000e+00, double* @global.1, align 8 - store double 0.000000e+00, double* @global.1, align 8 +; CHECK-NEXT: store double 0.000000e+00, ptr @global.1, align 8 + store double 0.000000e+00, ptr @global.1, align 8 ; CHECK: MemoryUse(2) ; MemoryUse(2) -; CHECK-NEXT: %tmp5 = load double, double* @global.1, align 8 - %tmp5 = load double, double* @global.1, align 8 +; CHECK-NEXT: %tmp5 = load double, ptr @global.1, align 8 + %tmp5 = load double, ptr @global.1, align 8 unreachable bb6: ; preds = %bb3 diff --git a/llvm/test/Analysis/MemorySSA/pr36883.ll b/llvm/test/Analysis/MemorySSA/pr36883.ll index cfbcc4cdf120..329026beb289 100644 --- a/llvm/test/Analysis/MemorySSA/pr36883.ll +++ b/llvm/test/Analysis/MemorySSA/pr36883.ll @@ -5,20 +5,20 @@ target triple = "armv7-dcg-linux-gnueabi" ; CHECK-LABEL: define <8 x i16> @vpx_idct32_32_neon -define <8 x i16> @vpx_idct32_32_neon(i8* %p, <8 x i16> %v) { +define <8 x i16> @vpx_idct32_32_neon(ptr %p, <8 x i16> %v) { entry: ; CHECK: MemoryUse(liveOnEntry) - %load1 = call <8 x i16> @llvm.arm.neon.vld1.v8i16.p0i8(i8* %p, i32 2) #4 ; load CSE replacement + %load1 = call <8 x i16> @llvm.arm.neon.vld1.v8i16.p0(ptr %p, i32 2) #4 ; load CSE replacement ; CHECK: 1 = MemoryDef(liveOnEntry) - call void @llvm.arm.neon.vst1.p0i8.v8i16(i8* %p, <8 x i16> %v, i32 2) #4 ; clobber + call void @llvm.arm.neon.vst1.p0.v8i16(ptr %p, <8 x i16> %v, i32 2) #4 ; clobber - %p_next = getelementptr inbounds i8, i8* %p, i32 16 + %p_next = getelementptr inbounds i8, ptr %p, i32 16 ; CHECK: MemoryUse(liveOnEntry) - %load2 = call <8 x i16> @llvm.arm.neon.vld1.v8i16.p0i8(i8* %p_next, i32 2) #4 ; non-aliasing load needed to trigger bug + %load2 = call <8 x i16> @llvm.arm.neon.vld1.v8i16.p0(ptr %p_next, i32 2) #4 ; non-aliasing load needed to trigger bug ; CHECK: MemoryUse(1) - %load3 = call <8 x i16> @llvm.arm.neon.vld1.v8i16.p0i8(i8* %p, i32 2) #4 ; load CSE removed + %load3 = call <8 x i16> @llvm.arm.neon.vld1.v8i16.p0(ptr %p, i32 2) #4 ; load CSE removed %add = add <8 x i16> %load1, %load2 %ret = add <8 x i16> %add, %load3 @@ -26,10 +26,10 @@ entry: } ; Function Attrs: argmemonly nounwind readonly -declare <8 x i16> @llvm.arm.neon.vld1.v8i16.p0i8(i8*, i32) #2 +declare <8 x i16> @llvm.arm.neon.vld1.v8i16.p0(ptr, i32) #2 ; Function Attrs: argmemonly nounwind -declare void @llvm.arm.neon.vst1.p0i8.v8i16(i8*, <8 x i16>, i32) #1 +declare void @llvm.arm.neon.vst1.p0.v8i16(ptr, <8 x i16>, i32) #1 attributes #1 = { argmemonly nounwind } attributes #2 = { argmemonly nounwind readonly } diff --git a/llvm/test/Analysis/MemorySSA/pr39197.ll b/llvm/test/Analysis/MemorySSA/pr39197.ll index 068d4f6fc438..2741509fdbf4 100644 --- a/llvm/test/Analysis/MemorySSA/pr39197.ll +++ b/llvm/test/Analysis/MemorySSA/pr39197.ll @@ -16,40 +16,40 @@ define dso_local void @main() #0 { } ; Function Attrs: argmemonly nounwind -declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1 +declare void @llvm.lifetime.end.p0(i64, ptr nocapture) #1 ; Function Attrs: nounwind define dso_local void @func_1() #0 { - %1 = alloca i32*, align 8 + %1 = alloca ptr, align 8 %2 = call signext i32 @func_2() %3 = icmp ne i32 %2, 0 br i1 %3, label %4, label %9 ;