LTO: Add option to initialize with opaque/non-opaque pointer types

[MatzeB]

Summary

LTO code may end up mixing bitcode files from various sources varying in their use of opaque pointer types. The current strategy to decide between opaque / typed pointers upon the first bitcode file loaded does not work here, since we could be loading a non-opaque bitcode file first and would then be unable to load any files with opaque pointer types later.

This enables/disables opaque pointers immediately when creating an LLVMContext for LTO. Opaque pointers are enabled by default.

• Adds an lto::Config::OpaquePointer option and enforces an upfront decision between the two modes.
• Adds -opaque-pointers/-no-opaque-pointers options to the gold plugin and lld; enabled by default.
• Adds an -lto-opaque-pointers/-lto-opaque-pointers=0 option to the llvm-lto2 tool.
• Changes the clang driver to pass -plugin-opt=no-opaque-pointers to the linker in LTO modes when clang was configured with opaque pointers disabled.

This fixes https://github.com/llvm/llvm-project/issues/55377

[MatzeB]

I am not completely sure however how to deal with users specifying -Xclang -no-opaque-pointers explicitly. With this change they would end up using opaque-pointers anyway in LTO modes...

Though without this change we have a some breakage here from builds mixing rust and clang produced bitcode.

[ChuanqiXu]

I think it is better to add some tests at least.

[nikic]

Related bug report: https://github.com/llvm/llvm-project/issues/55377

In D125847#3521080, @MatzeB wrote:

I am not completely sure however how to deal with users specifying -Xclang -no-opaque-pointers explicitly. With this change they would end up using opaque-pointers anyway in LTO modes...

I believe the right way to do this is to add an OpaquePointers option to lto::Config, add -plugin-opt=no-opaque-pointers to LLD/LLVMgold.so, and then pass that from clang.

Alternatively we could just drop support for LTO with typed pointers :)

[aeubanks]

In D125847#3521583, @nikic wrote:

Related bug report: https://github.com/llvm/llvm-project/issues/55377

In D125847#3521080, @MatzeB wrote:

I am not completely sure however how to deal with users specifying -Xclang -no-opaque-pointers explicitly. With this change they would end up using opaque-pointers anyway in LTO modes...

I believe the right way to do this is to add an OpaquePointers option to lto::Config, add -plugin-opt=no-opaque-pointers to LLD/LLVMgold.so, and then pass that from clang.

Alternatively we could just drop support for LTO with typed pointers :)

+1 to adding something to lto::Config.

[MatzeB]

In D125847#3521583, @nikic wrote:

Alternatively we could just drop support for LTO with typed pointers :)

Admittedly I do feel better having an emergency shut-off flag around for now; But -mllvm -opaque-pointers=0 is enough for that I think.

[MatzeB]

update tests

[MatzeB]

+1 to adding something to lto::Config.

Do we really need this for a temporary switch? Will this force us to keep supporting the new switch into the future for backwards compatibility in the commandline interface even when we dropped all references to typed pointers from LLVM?

[aeubanks]

In D125847#3523502, @MatzeB wrote:

+1 to adding something to lto::Config.

Do we really need this for a temporary switch? Will this force us to keep supporting the new switch into the future for backwards compatibility in the commandline interface even when we dropped all references to typed pointers from LLVM?

You mentioned that -mllvm -opaque-pointers=0 is a temporary workaround with this patch, but -mllvm -opaque-pointers=1 works just fine for what this patch is trying to do. I think respecting -Xclang -[no-]opaque-pointers when performing LTO is desirable, and for that you'd need the lto::Config change.

We've removed a bunch of legacy/new pass manager switches, I don't see why we'd keep this switch around.

[MaskRay]

llvm/include/llvm/LTO/Config.h

300

delete braces

[MatzeB]

While trying to implement things I noticed that -Xclang options are only meant for the LLVM codegeneration part (aka CC1) of clang, they are not meant for the linker/LTO (which would be -Xlinker or -Wl) and consequently there is no easy way in the code to query -Xclang options and pass them on to the linker (nor would it be a good idea I think).

The usual approach seems to be that codegen options are recorded in the IR as much as possible so we can reconstruct the settings from that during LTO. This is however awkward in this case, as we have to make the decision between opaque/typed pointer types before reading the first bitcode file and cannot really go back and undo it...

I think what I'm gonna do is:

• Add an LTOConfig option for opaque pointers, disabled by default
• Add -opaque-pointer, -no-opaque-pointer options to gold-plugin and lld/ELF, disabled by default
• Have clang pass a -opaque-pointer option to lld if CLANG_ENABLE_OPAQUE_POINTERS_INTERNAL was enabled during the build and the user didn't pass any other -opaque-pointer/-no-opaque-pointer option via -Wl / -Xlinker.

[MatzeB]

Changed the approach a bit; summary (and tests) are updated.

[nikic]

llvm/include/llvm/LTO/Config.h

182

The default should be true here and for the LLD/LLVMgold flags, to match the Clang default and upcoming LLVM default. It's also the conservative option, because OpaquePointers=true will work fine with typed bitcode, but not the other way around. As this change disables the auto-detection, leaving the default to off would be a big footgun for anyone invoking LTO through the linker rather than the clang driver.

[steven_wu]

Is there any issues currently if we just always use opaque pointer in LTO?

[aeubanks]

I'm still looking into a whole program devirtualization bug that only repros with opaque pointers, and there are still potential performance issues to look into

[steven_wu]

In D125847#3528111, @aeubanks wrote:

I'm still looking into a whole program devirtualization bug that only repros with opaque pointers, and there are still potential performance issues to look into

Thanks. Maybe here is another way to look at this problem, instead of giving people a temporary switch to use opaque_pointer if their first bitcode is no_opaque_pointer, we opt as aggressive as possible into opaque_pointer and give people a temporary switch to go back to old behavior just like how clang is configured.

[MaskRay]

lld/ELF/Options.td

629

The convention is =opaque-pointers

[MatzeB]

Enable LTO by default and fix a whole bunch of LTO tests because of it.

[nikic]

Looks reasonable to me, but probably @MaskRay should review.

We could add a -fno-opaque-pointers driver option that covers both the compiler backend and LTO, but we can probably get away without it as well.

lld/ELF/Options.td

311

(default) here is outdated.

Possibly this option should be lto_opaque_pointers? That seems to be the convention for other related options.

llvm/docs/OpaquePointers.rst

71

-plugin-opt=opaque-pointers. Though it probably makes more sense now to mention this at the end of the document, as an option to disable.

[MatzeB]

Address review feedback.

[MatzeB]

lld/ELF/Options.td

311

👍

[nikic]

LGTM

clang/test/CodeGen/thinlto-inline-asm2.c

6

I don't think this is needed for cc1 invocations (they should always default to opaque pointers).

[MaskRay]

Adds -opaque-pointers/-no-opaque-pointers options to the gold plugin; disabled by default.

-plugin-opt=[no-]opaque-pointers

--opaque-pointers/--no-opaque-pointers options with -plugin-opt=-opaque-pointers/-plugin-opt=-no-opaque-pointers aliases to lld; disabled by default.

For such temporary options, don't add regular options. Just add -plugin-opt=[no-]opaque-pointers.

Changes the clang driver to pass -plugin-opt=-opaque-pointers to the linker in LTO modes when clang was configured with opaque pointers enabled by default.

-plugin-opt=no-opaque-pointers

[MaskRay]

clang/test/Driver/lto-no-opaque-pointers.c

3

-target is a legacy option. Use --target= for new tests.

No need to use check fd 2 (2> %t). There is sufficient coverage testing that the options are in fd 2.

Just use 2>&1 | FileCheck %s.

clang/test/Driver/lto-opaque-pointers.c

3

ditto

[MatzeB]

address review feedback. I assume this is accepted and good to push when the buildkit builds look reasonable.

[MaskRay]

LTO: Decide upfront whether to use opaque/non-opaque pointer types

This may need to mention "add options" to decide <...>

[MaskRay]

llvm/tools/gold/gold-plugin.cpp

966

Conf?

[MatzeB]

llvm/tools/gold/gold-plugin.cpp

966

Ouch, good catch. Guess we have no form of direct testing of the gold plugin in LLVM...

[MaskRay]

In D125847#3551841, @MatzeB wrote:

address review feedback. I assume this is accepted and good to push when the buildkit builds look reasonable.

(I changed myself to a blocking review to check the component I mostly care about. I promise I'll perform a quick check.)

[MaskRay]

llvm/tools/gold/gold-plugin.cpp

966

Sanitizers have bots using -DLLVM_BINUTILS_INCDIR=/usr/include, but otherwise using this option is uncommon among build bots.

[MatzeB]

In D125847#3551972, @MaskRay wrote:

In D125847#3551841, @MatzeB wrote:

address review feedback. I assume this is accepted and good to push when the buildkit builds look reasonable.

(I changed myself to a blocking review to check the component I mostly care about. I promise I'll perform a quick check.)

Of course, I won't push then. I wasn't sure since the accept came after the set to block.

[MaskRay]

Your commit message seems to use the original summary.

[Jake-Egan]

Hi, this caused arm-float-abi-lto.c to fail on AIX. The failure went away for a few builds, then came back. Could you take a look?

https://lab.llvm.org/buildbot/#/builders/214/builds/1625/steps/6/logs/FAIL__Clang__arm-float-abi-lto_c

[MatzeB]

In D125847#3554569, @Jake-Egan wrote:

Hi, this caused arm-float-abi-lto.c to fail on AIX. The failure went away for a few builds, then came back. Could you take a look?

https://lab.llvm.org/buildbot/#/builders/214/builds/1625/steps/6/logs/FAIL__Clang__arm-float-abi-lto_c

Uh, this change just enables opaque pointers for this test. And it appears to be crashing nondeterministically somewhere within LLVM. Unfortunately I don't see this happening on my X86 development machine. None of the ASAN enabled buildbots appears to complain either. I don't know how to even start debugging this, do you have at least a stacktrace?

[Jake-Egan]

In D125847#3554706, @MatzeB wrote:

In D125847#3554569, @Jake-Egan wrote:

Hi, this caused arm-float-abi-lto.c to fail on AIX. The failure went away for a few builds, then came back. Could you take a look?

https://lab.llvm.org/buildbot/#/builders/214/builds/1625/steps/6/logs/FAIL__Clang__arm-float-abi-lto_c

Uh, this change just enables opaque pointers for this test. And it appears to be crashing nondeterministically somewhere within LLVM. Unfortunately I don't see this happening on my X86 development machine. None of the ASAN enabled buildbots appears to complain either. I don't know how to even start debugging this, do you have at least a stacktrace?

Sorry about the delayed response. Marking the test unsupported on AIX for now: c3c75d805c2174388417080f762230961b3433d6 Here is a stack trace:

#0  0x0000000100013e50 in llvm::StringRef::find(llvm::StringRef, unsigned long) const ()
#1  0x0000000101b17fd4 in llvm::ARM_MC::ParseARMTriple(llvm::Triple const&, llvm::StringRef) ()
#2  0x0000000102c16294 in llvm::ARMAsmPrinter::emitAttributes() ()
#3  0x0000000102c16008 in llvm::ARMAsmPrinter::emitStartOfAsmFile(llvm::Module&) ()
#4  0x0000000102a6a980 in llvm::AsmPrinter::doInitialization(llvm::Module&) ()
#5  0x00000001001bdecc in llvm::FPPassManager::doInitialization(llvm::Module&) ()
#6  0x0000000103c9d2a0 in llvm::legacy::PassManagerImpl::run(llvm::Module&) ()
#7  0x0000000103c9ce34 in llvm::legacy::PassManager::run(llvm::Module&) ()
#8  0x0000000103c97014 in codegen(llvm::lto::Config const&, llvm::TargetMachine*, std::__1::function<llvm::Expected<std::__1::unique_ptr<llvm::CachedFileStream, std::__1::default_delete<llvm::CachedFileStream> > > (unsigned int)>, unsigned int, llvm::Module&, llvm::ModuleSummaryIndex const&) ()
#9  0x00000001030105c0 in llvm::lto::thinBackend(llvm::lto::Config const&, unsigned int, std::__1::function<llvm::Expected<std::__1::unique_ptr<llvm::CachedFileStream, std::__1::default_delete<llvm::CachedFileStream> > > (unsigned int)>, llvm::Module&, llvm::ModuleSummaryIndex const&, llvm::StringMap<std::__1::unordered_set<unsigned long, std::__1::hash<unsigned long>, std::__1::equal_to<unsigned long>, std::__1::allocator<unsigned long> >, llvm::MallocAllocator> const&, llvm::DenseMap<unsigned long, llvm::GlobalValueSummary*, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::GlobalValueSummary*> > const&, llvm::MapVector<llvm::StringRef, llvm::BitcodeModule, llvm::DenseMap<llvm::StringRef, unsigned int, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, unsigned int> >, std::__1::vector<std::__1::pair<llvm::StringRef, llvm::BitcodeModule>, std::__1::allocator<std::__1::pair<llvm::StringRef, llvm::BitcodeModule> > > >*, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> > const&)::$_3::operator()(llvm::Module&, llvm::TargetMachine*, std::__1::unique_ptr<llvm::ToolOutputFile, std::__1::default_delete<llvm::ToolOutputFile> >) const ()
#10 0x0000000103000b54 in llvm::lto::thinBackend(llvm::lto::Config const&, unsigned int, std::__1::function<llvm::Expected<std::__1::unique_ptr<llvm::CachedFileStream, std::__1::default_delete<llvm::CachedFileStream> > > (unsigned int)>, llvm::Module&, llvm::ModuleSummaryIndex const&, llvm::StringMap<std::__1::unordered_set<unsigned long, std::__1::hash<unsigned long>, std::__1::equal_to<unsigned long>, std::__1::allocator<unsigned long> >, llvm::MallocAllocator> const&, llvm::DenseMap<unsigned long, llvm::GlobalValueSummary*, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::GlobalValueSummary*> > const&, llvm::MapVector<llvm::StringRef, llvm::BitcodeModule, llvm::DenseMap<llvm::StringRef, unsigned int, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, unsigned int> >, std::__1::vector<std::__1::pair<llvm::StringRef, llvm::BitcodeModule>, std::__1::allocator<std::__1::pair<llvm::StringRef, llvm::BitcodeModule> > > >*, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> > const&) ()
#11 0x0000000102fff380 in (anonymous namespace)::InProcessThinBackend::runThinLTOBackendThread(std::__1::function<llvm::Expected<std::__1::unique_ptr<llvm::CachedFileStream, std::__1::default_delete<llvm::CachedFileStream> > > (unsigned int)>, std::__1::function<llvm::Expected<std::__1::function<llvm::Expected<std::__1::unique_ptr<llvm::CachedFileStream, std::__1::default_delete<llvm::CachedFileStream> > > (unsigned int)> > (unsigned int, llvm::StringRef)>, unsigned int, llvm::BitcodeModule, llvm::ModuleSummaryIndex&, llvm::StringMap<std::__1::unordered_set<unsigned long, std::__1::hash<unsigned long>, std::__1::equal_to<unsigned long>, std::__1::allocator<unsigned long> >, llvm::MallocAllocator> const&, llvm::DenseSet<llvm::ValueInfo, llvm::DenseMapInfo<llvm::ValueInfo, void> > const&, std::__1::map<unsigned long, llvm::GlobalValue::LinkageTypes, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, llvm::GlobalValue::LinkageTypes> > > const&, llvm::DenseMap<unsigned long, llvm::GlobalValueSummary*, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::GlobalValueSummary*> > const&, llvm::MapVector<llvm::StringRef, llvm::BitcodeModule, llvm::DenseMap<llvm::StringRef, unsigned int, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, unsigned int> >, std::__1::vector<std::__1::pair<llvm::StringRef, llvm::BitcodeModule>, std::__1::allocator<std::__1::pair<llvm::StringRef, llvm::BitcodeModule> > > >&)::{lambda(std::__1::function<llvm::Expected<std::__1::unique_ptr<llvm::CachedFileStream, std::__1::default_delete<llvm::CachedFileStream> > > (unsigned int)>)#1}::operator()(std::__1::function<llvm::Expected<std::__1::unique_ptr<llvm::CachedFileStream, std::__1::default_delete<llvm::CachedFileStream> > > (unsigned int)>) const ()
#12 0x0000000102ffe54c in std::__1::__function::__func<std::__1::__bind<(anonymous namespace)::InProcessThinBackend::start(unsigned int, llvm::BitcodeModule, llvm::StringMap<std::__1::unordered_set<unsigned long, std::__1::hash<unsigned long>, std::__1::equal_to<unsigned long>, std::__1::allocator<unsigned long> >, llvm::MallocAllocator> const&, llvm::DenseSet<llvm::ValueInfo, llvm::DenseMapInfo<llvm::ValueInfo, void> > const&, std::__1::map<unsigned long, llvm::GlobalValue::LinkageTypes, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, llvm::GlobalValue::LinkageTypes> > > const&, llvm::MapVector<llvm::StringRef, llvm::BitcodeModule, llvm::DenseMap<llvm::StringRef, unsigned int, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, unsigned int> >, std::__1::vector<std::__1::pair<llvm::StringRef, llvm::BitcodeModule>, std::__1::allocator<std::__1::pair<llvm::StringRef, llvm::BitcodeModule> > > >&)::{lambda(llvm::BitcodeModule, llvm::ModuleSummaryIndex&, llvm::StringMap<std::__1::unordered_set<unsigned long, std::__1::hash<unsigned long>, std::__1::equal_to<unsigned long>, std::__1::allocator<unsigned long> >, llvm::MallocAllocator> const&, llvm::DenseSet<llvm::ValueInfo, llvm::DenseMapInfo<llvm::ValueInfo, void> > const&, std::__1::map<unsigned long, llvm::GlobalValue::LinkageTypes, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, llvm::GlobalValue::LinkageTypes> > > const&, llvm::DenseMap<unsigned long, llvm::GlobalValueSummary*, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::GlobalValueSummary*> > const&, llvm::MapVector<llvm::StringRef, llvm::BitcodeModule, llvm::DenseMap<llvm::StringRef, unsigned int, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, unsigned int> >, std::__1::vector<std::__1::pair<llvm::StringRef, llvm::BitcodeModule>, std::__1::allocator<std::__1::pair<llvm::StringRef, llvm::BitcodeModule> > > >&)#1}, llvm::BitcodeModule&, std::__1::reference_wrapper<llvm::ModuleSummaryIndex>, std::__1::reference_wrapper<llvm::StringMap<std::__1::unordered_set<unsigned long, std::__1::hash<unsigned long>, std::__1::equal_to<unsigned long>, std::__1::allocator<unsigned long> >, llvm::MallocAllocator> const>, std::__1::reference_wrapper<llvm::DenseSet<llvm::ValueInfo, llvm::DenseMapInfo<llvm::ValueInfo, void> > const>, std::__1::reference_wrapper<std::__1::map<unsigned long, llvm::GlobalValue::LinkageTypes, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, llvm::GlobalValue::LinkageTypes> > > const>, std::__1::reference_wrapper<llvm::DenseMap<unsigned long, llvm::GlobalValueSummary*, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::GlobalValueSummary*> > const>, std::__1::reference_wrapper<llvm::MapVector<llvm::StringRef, llvm::BitcodeModule, llvm::DenseMap<llvm::StringRef, unsigned int, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, unsigned int> >, std::__1::vector<std::__1::pair<llvm::StringRef, llvm::BitcodeModule>, std::__1::allocator<std::__1::pair<llvm::StringRef, llvm::BitcodeModule> > > > > >, std::__1::allocator<std::__1::__bind<(anonymous namespace)::InProcessThinBackend::start(unsigned int, llvm::BitcodeModule, llvm::StringMap<std::__1::unordered_set<unsigned long, std::__1::hash<unsigned long>, std::__1::equal_to<unsigned long>, std::__1::allocator<unsigned long> >, llvm::MallocAllocator> const&, llvm::DenseSet<llvm::ValueInfo, llvm::DenseMapInfo<llvm::ValueInfo, void> > const&, std::__1::map<unsigned long, llvm::GlobalValue::LinkageTypes, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, llvm::GlobalValue::LinkageTypes> > > const&, llvm::MapVector<llvm::StringRef, llvm::BitcodeModule, llvm::DenseMap<llvm::StringRef, unsigned int, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, unsigned int> >, std::__1::vector<std::__1::pair<llvm::StringRef, llvm::BitcodeModule>, std::__1::allocator<std::__1::pair<llvm::StringRef, llvm::BitcodeModule> > > >&)::{lambda(llvm::BitcodeModule, llvm::ModuleSummaryIndex&, llvm::StringMap<std::__1::unordered_set<unsigned long, std::__1::hash<unsigned long>, std::__1::equal_to<unsigned long>, std::__1::allocator<unsigned long> >, llvm::MallocAllocator> const&, llvm::DenseSet<llvm::ValueInfo, llvm::DenseMapInfo<llvm::ValueInfo, void> > const&, std::__1::map<unsigned long, llvm::GlobalValue::LinkageTypes, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, llvm::GlobalValue::LinkageTypes> > > const&, llvm::DenseMap<unsigned long, llvm::GlobalValueSummary*, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::GlobalValueSummary*> > const&, llvm::MapVector<llvm::StringRef, llvm::BitcodeModule, llvm::DenseMap<llvm::StringRef, unsigned int, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, unsigned int> >, std::__1::vector<std::__1::pair<llvm::StringRef, llvm::BitcodeModule>, std::__1::allocator<std::__1::pair<llvm::StringRef, llvm::BitcodeModule> > > >&)#1}, llvm::BitcodeModule&, std::__1::reference_wrapper<llvm::ModuleSummaryIndex>, std::__1::reference_wrapper<llvm::StringMap<std::__1::unordered_set<unsigned long, std::__1::hash<unsigned long>, std::__1::equal_to<unsigned long>, std::__1::allocator<unsigned long> >, llvm::MallocAllocator> const>, std::__1::reference_wrapper<llvm::DenseSet<llvm::ValueInfo, llvm::DenseMapInfo<llvm::ValueInfo, void> > const>, std::__1::reference_wrapper<std::__1::map<unsigned long, llvm::GlobalValue::LinkageTypes, std::__1::less<unsigned long>, std::__1::allocator<std::__1::pair<unsigned long const, llvm::GlobalValue::LinkageTypes> > > const>, std::__1::reference_wrapper<llvm::DenseMap<unsigned long, llvm::GlobalValueSummary*, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::GlobalValueSummary*> > const>, std::__1::reference_wrapper<llvm::MapVector<llvm::StringRef, llvm::BitcodeModule, llvm::DenseMap<llvm::StringRef, unsigned int, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, unsigned int> >, std::__1::vector<std::__1::pair<llvm::StringRef, llvm::BitcodeModule>, std::__1::allocator<std::__1::pair<llvm::StringRef, llvm::BitcodeModule> > > > > > >, void ()>::operator()() ()
#13 0x0000000103caa248 in std::__1::__function::__func<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::{lambda()#1}, std::__1::allocator<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::{lambda()#1}>, void ()>::operator()() ()
#14 0x0000000103caba5c in llvm::ThreadPool::processTasks(llvm::ThreadPoolTaskGroup*) ()
#15 0x0000000103cab3e4 in void* llvm::thread::ThreadProxy<std::__1::tuple<llvm::ThreadPool::grow(int)::$_0> >(void*) ()
#16 0x09000000005b304c in _pthread_body () from /usr/lib/libpthreads.a(shr_xpg5_64.o)
#17 0x0000000000000000 in ?? ()

[MaskRay]

I see that clang/test/Driver/arm-float-abi-lto.c now has a // UNSUPPORTED: system-aix workaround but I think someone working on AIX should investigate the issue.
I think the reported issue isn't actionable to those who don't use AIX.

[bmahjour]

lld/test/ELF/lto/discard-value-names.ll

4

I see --plugin-opt=opaque-pointers is being explicitly specified for some but not all tests. I suppose the reason you explicitly specify it is to make sure the tests pass even for builds where opaque pointers are disabled. If that's the case, why aren't you doing it consistently?

llvm/test/Analysis/StackSafetyAnalysis/ipa.ll

86

why does this test (and ipa-alias.ll above) need to run with opaque pointers off?

llvm/test/LTO/Resolution/X86/alias-alias.ll

3

Why do you pass -lto-opaque-pointers to llvm-lto2 in clang/tests but not here?

[MatzeB]

lld/test/ELF/lto/discard-value-names.ll

4

It‘s not specified in any of the lld tests except the two tests for the option itself (because in lld lto its enabled by default now).

It is specified for clang (but not clang cc1) in a coupletests because the clang driver drfaults can currently be changed with a cmake flag.

llvm/test/Analysis/StackSafetyAnalysis/ipa.ll

86

I don‘t remember this test specifically but some were tricky to update, feel free to submit a patch.

[MatzeB]

@JakeEgan I did a quick look for the code in that stacktrace but nothing jumped out on me. It‘s with inlining effects obscuring it. But I think that crash must be investigated on an AIX machine, there‘s no indication that this directly related to my change which works on all other systems.

[MatzeB]

In D125847#3552297, @MaskRay wrote:

Your commit message seems to use the original summary.

Yes sorry, I noticed it too after pushing it. I think this can‘t be fixed after the push though…

[Jake-Egan]

Thanks for taking a look. I agree someone on AIX should investigate.

clang/lib/Driver/ToolChains/CommonArgs.cpp

#endif
   if (IsThinLTO)
     CmdArgs.push_back("-plugin-opt=thinlto");
 
   StringRef Parallelism = getLTOParallelism(Args, D);
   if (!Parallelism.empty())
     CmdArgs.push_back(
         Args.MakeArgString("-plugin-opt=jobs=" + Twine(Parallelism)));
 
+  if (!CLANG_ENABLE_OPAQUE_POINTERS_INTERNAL)
+    CmdArgs.push_back(Args.MakeArgString("-plugin-opt=no-opaque-pointers"));
+
   // If an explicit debugger tuning argument appeared, pass it along.
   if (Arg *A = Args.getLastArg(options::OPT_gTune_Group,
                                options::OPT_ggdbN_Group)) {
     if (A->getOption().matches(options::OPT_glldb))
       CmdArgs.push_back("-plugin-opt=-debugger-tune=lldb");
     else if (A->getOption().matches(options::OPT_gsce))
       CmdArgs.push_back("-plugin-opt=-debugger-tune=sce");
     else if (A->getOption().matches(options::OPT_gdbx))

clang/test/CodeGen/thinlto-inline-asm2.c

 // REQUIRES: x86-registered-target
 
 // RUN: split-file %s %t
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -flto=thin -emit-llvm-bc %t/a.c -o %t/a.bc
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -flto=thin -emit-llvm-bc %t/b.c -o %t/b.bc
 // RUN: llvm-nm %t/a.bc | FileCheck %s --check-prefix=NM
 
-// RUN: llvm-lto2 run %t/a.bc %t/b.bc -o %t/out -save-temps -r=%t/a.bc,ref,plx -r=%t/b.bc,ff_h264_cabac_tables,pl
+// RUN: llvm-lto2 run -lto-opaque-pointers %t/a.bc %t/b.bc -o %t/out -save-temps -r=%t/a.bc,ref,plx -r=%t/b.bc,ff_h264_cabac_tables,pl
 // RUN: llvm-dis < %t/out.2.2.internalize.bc | FileCheck %s
 
 //--- a.c
 /// IR symtab does not track inline asm symbols, so we don't know
 /// ff_h264_cabac_tables is undefined.
 // NM-NOT: {{.}}
 // NM:     ---------------- T ref
 // NM-NOT: {{.}}

clang/test/Driver/arm-float-abi-lto.c

 // REQUIRES: arm-registered-target
 
 // RUN: %clang --target=arm-none-eabi -mcpu=cortex-m33 -mfloat-abi=hard -O1 %s -S -o - -emit-llvm -DCALL_LIB -DDEFINE_LIB | FileCheck %s
 
-// RUN: %clang --target=arm-none-eabi -mcpu=cortex-m33 -mfloat-abi=hard -O1 %s -flto=full -c -o %t.call_full.bc -DCALL_LIB
-// RUN: %clang --target=arm-none-eabi -mcpu=cortex-m33 -mfloat-abi=hard -O1 %s -flto=full -c -o %t.define_full.bc -DDEFINE_LIB
-// RUN: llvm-lto2 run -o %t.lto_full -save-temps %t.call_full.bc %t.define_full.bc \
+// RUN: %clang --target=arm-none-eabi -mcpu=cortex-m33 -mfloat-abi=hard -O1 %s -Xclang -opaque-pointers -flto=full -c -o %t.call_full.bc -DCALL_LIB
+// RUN: %clang --target=arm-none-eabi -mcpu=cortex-m33 -mfloat-abi=hard -O1 %s -Xclang -opaque-pointers -flto=full -c -o %t.define_full.bc -DDEFINE_LIB
+// RUN: llvm-lto2 run -lto-opaque-pointers -o %t.lto_full -save-temps %t.call_full.bc %t.define_full.bc \
 // RUN:  -r %t.call_full.bc,fn,px \
 // RUN:  -r %t.call_full.bc,fwrite,l \
 // RUN:  -r %t.call_full.bc,putchar,l \
 // RUN:  -r %t.call_full.bc,stdout,px \
 // RUN:  -r %t.define_full.bc,fwrite,px \
 // RUN:  -r %t.define_full.bc,putchar,px \
 // RUN:  -r %t.define_full.bc,otherfn,px
 // RUN: llvm-dis %t.lto_full.0.4.opt.bc -o - | FileCheck %s
 
-// RUN: %clang --target=arm-none-eabi -mcpu=cortex-m33 -mfloat-abi=hard -O1 %s -flto=thin -c -o %t.call_thin.bc -DCALL_LIB
-// RUN: %clang --target=arm-none-eabi -mcpu=cortex-m33 -mfloat-abi=hard -O1 %s -flto=thin -c -o %t.define_thin.bc -DDEFINE_LIB
-// RUN: llvm-lto2 run -o %t.lto_thin -save-temps %t.call_thin.bc %t.define_thin.bc \
+// RUN: %clang --target=arm-none-eabi -mcpu=cortex-m33 -mfloat-abi=hard -O1 %s -Xclang -opaque-pointers -flto=thin -c -o %t.call_thin.bc -DCALL_LIB
+// RUN: %clang --target=arm-none-eabi -mcpu=cortex-m33 -mfloat-abi=hard -O1 %s -Xclang -opaque-pointers -flto=thin -c -o %t.define_thin.bc -DDEFINE_LIB
+// RUN: llvm-lto2 run -lto-opaque-pointers -o %t.lto_thin -save-temps %t.call_thin.bc %t.define_thin.bc \
 // RUN:  -r %t.call_thin.bc,fn,px \
 // RUN:  -r %t.call_thin.bc,fwrite,l \
 // RUN:  -r %t.call_thin.bc,putchar,l \
 // RUN:  -r %t.call_thin.bc,stdout,px \
 // RUN:  -r %t.define_thin.bc,fwrite,px \
 // RUN:  -r %t.define_thin.bc,putchar,px \
 // RUN:  -r %t.define_thin.bc,otherfn,px
 // RUN: llvm-dis %t.lto_thin.1.4.opt.bc -o - | FileCheck %s

clang/test/Driver/lto-no-opaque-pointers.c

+// UNSUPPORTED: enable-opaque-pointers
+// RUN: %clang --target=x86_64-unknown-linux -### %s -flto 2> %t
+// RUN: FileCheck %s < %t
+
+// CHECK: -plugin-opt=no-opaque-pointers

clang/test/Driver/lto-opaque-pointers.c

+// REQUIRES: enable-opaque-pointers
+// RUN: %clang --target=x86_64-unknown-linux -### %s -flto 2> %t
+// RUN: FileCheck %s < %t
+
+// CHECK-NOT: -plugin-opt=no-opaque-pointers

clang/test/Driver/memtag_lto.c

 // REQUIRES: aarch64-registered-target
 
 // No MTE, so no StackSafety.
 
 // RUN: rm -f %t*
 
 // -O1, no tagging
 // RUN: %clang -O1 -target aarch64-unknown-linux -mllvm -stack-safety-print %s -S -o - 2>&1 | FileCheck %s
 
 // Full LTO
-// RUN: %clang -O1 -target aarch64-unknown-linux -c %s -flto=full -o %t.ltonewpm1.bc
-// RUN: %clang -O1 -target aarch64-unknown-linux -c -DBUILD2 %s -flto=full -o %t.ltonewpm2.bc
-// RUN: llvm-lto2 run -o %t.ltonewpm %t.ltonewpm1.bc %t.ltonewpm2.bc -save-temps -stack-safety-print -thinlto-threads 1 -O1 \
+// RUN: %clang -O1 -target aarch64-unknown-linux -c %s -Xclang -opaque-pointers -flto=full -o %t.ltonewpm1.bc
+// RUN: %clang -O1 -target aarch64-unknown-linux -c -DBUILD2 %s -Xclang -opaque-pointers -flto=full -o %t.ltonewpm2.bc
+// RUN: llvm-lto2 run -lto-opaque-pointers -o %t.ltonewpm %t.ltonewpm1.bc %t.ltonewpm2.bc -save-temps -stack-safety-print -thinlto-threads 1 -O1 \
 // RUN:  -r %t.ltonewpm1.bc,fn,plx \
 // RUN:  -r %t.ltonewpm1.bc,use,lx \
 // RUN:  -r %t.ltonewpm1.bc,use_local,plx \
 // RUN:  -r %t.ltonewpm1.bc,w, \
 // RUN:  -r %t.ltonewpm2.bc,use,plx \
 // RUN:  -r %t.ltonewpm2.bc,z, 2>&1 | FileCheck %s --allow-empty
 
 // Thin LTO, new PM
-// RUN: %clang -O1 -target aarch64-unknown-linux -c %s -flto=thin -o %t.thinltonewpm1.bc
-// RUN: %clang -O1 -target aarch64-unknown-linux -c -DBUILD2 %s -flto=thin -o %t.thinltonewpm2.bc
-// RUN: llvm-lto2 run -o %t.thinltonewpm %t.thinltonewpm1.bc %t.thinltonewpm2.bc -save-temps -stack-safety-print -thinlto-threads 1 -O1 \
+// RUN: %clang -O1 -target aarch64-unknown-linux -c %s -Xclang -opaque-pointers -flto=thin -o %t.thinltonewpm1.bc
+// RUN: %clang -O1 -target aarch64-unknown-linux -c -DBUILD2 %s -Xclang -opaque-pointers -flto=thin -o %t.thinltonewpm2.bc
+// RUN: llvm-lto2 run -lto-opaque-pointers -o %t.thinltonewpm %t.thinltonewpm1.bc %t.thinltonewpm2.bc -save-temps -stack-safety-print -thinlto-threads 1 -O1 \
 // RUN:  -r %t.thinltonewpm1.bc,fn,plx \
 // RUN:  -r %t.thinltonewpm1.bc,use,lx \
 // RUN:  -r %t.thinltonewpm1.bc,use_local,plx \
 // RUN:  -r %t.thinltonewpm1.bc,w, \
 // RUN:  -r %t.thinltonewpm2.bc,use,plx \
 // RUN:  -r %t.thinltonewpm2.bc,z, 2>&1 | FileCheck %s --allow-empty
 
 // Now with MTE.
 // RUN: rm -f %t*
 
 // -O0: both are unsafe.
 // RUN: %clang -O0 -target aarch64-unknown-linux -march=armv8+memtag -fsanitize=memtag -mllvm -stack-safety-print %s -S -o - 2>&1 | FileCheck %s
 
 // No LTO: just one is safe.
 // RUN: %clang -O1 -target aarch64-unknown-linux -march=armv8+memtag -fsanitize=memtag -mllvm -stack-safety-print %s -S -o /dev/null 2>&1 | FileCheck %s -check-prefixes=SSI,XUNSAFE,YSAFE
 
 // Full LTO: both are safe.
-// RUN: %clang -O1 -target aarch64-unknown-linux -march=armv8+memtag -fsanitize=memtag -c %s -flto=full -o %t.ltonewpm1.bc
-// RUN: %clang -O1 -target aarch64-unknown-linux -march=armv8+memtag -fsanitize=memtag -c -DBUILD2 %s -flto=full -o %t.ltonewpm2.bc
-// RUN: llvm-lto2 run -o %t.ltonewpm %t.ltonewpm1.bc %t.ltonewpm2.bc -save-temps -stack-safety-print -thinlto-threads 1 -O1 \
+// RUN: %clang -O1 -target aarch64-unknown-linux -march=armv8+memtag -fsanitize=memtag -c %s -Xclang -opaque-pointers -flto=full -o %t.ltonewpm1.bc
+// RUN: %clang -O1 -target aarch64-unknown-linux -march=armv8+memtag -fsanitize=memtag -c -DBUILD2 %s -Xclang -opaque-pointers -flto=full -o %t.ltonewpm2.bc
+// RUN: llvm-lto2 run -lto-opaque-pointers -o %t.ltonewpm %t.ltonewpm1.bc %t.ltonewpm2.bc -save-temps -stack-safety-print -thinlto-threads 1 -O1 \
 // RUN:  -r %t.ltonewpm1.bc,fn,plx \
 // RUN:  -r %t.ltonewpm1.bc,use,lx \
 // RUN:  -r %t.ltonewpm1.bc,use_local,plx \
 // RUN:  -r %t.ltonewpm1.bc,w, \
 // RUN:  -r %t.ltonewpm2.bc,use,plx \
 // RUN:  -r %t.ltonewpm2.bc,z, 2>&1 | FileCheck %s -check-prefixes=SSI,XSAFE,YSAFE
 
 // Thin LTO: both are safe.
-// RUN: %clang -O1 -target aarch64-unknown-linux -march=armv8+memtag -fsanitize=memtag -c %s -flto=thin -o %t.thinltonewpm1.bc
-// RUN: %clang -O1 -target aarch64-unknown-linux -march=armv8+memtag -fsanitize=memtag -c -DBUILD2 %s -flto=thin -o %t.thinltonewpm2.bc
-// RUN: llvm-lto2 run -o %t.thinltonewpm %t.thinltonewpm1.bc %t.thinltonewpm2.bc -save-temps -stack-safety-print -thinlto-threads 1 -O1 \
+// RUN: %clang -O1 -target aarch64-unknown-linux -march=armv8+memtag -fsanitize=memtag -c %s -Xclang -opaque-pointers -flto=thin -o %t.thinltonewpm1.bc
+// RUN: %clang -O1 -target aarch64-unknown-linux -march=armv8+memtag -fsanitize=memtag -c -DBUILD2 %s -Xclang -opaque-pointers -flto=thin -o %t.thinltonewpm2.bc
+// RUN: llvm-lto2 run -lto-opaque-pointers -o %t.thinltonewpm %t.thinltonewpm1.bc %t.thinltonewpm2.bc -save-temps -stack-safety-print -thinlto-threads 1 -O1 \
 // RUN:  -r %t.thinltonewpm1.bc,fn,plx \
 // RUN:  -r %t.thinltonewpm1.bc,use,lx \
 // RUN:  -r %t.thinltonewpm1.bc,use_local,plx \
 // RUN:  -r %t.thinltonewpm1.bc,w, \
 // RUN:  -r %t.thinltonewpm2.bc,use,plx \
 // RUN:  -r %t.thinltonewpm2.bc,z, 2>&1 | FileCheck %s -check-prefixes=SSI,XSAFE,YSAFE
 
 void use(int *p);

lld/ELF/Config.h

struct Configuration {
   bool mipsN32Abi = false;
   bool mmapOutputFile;
   bool nmagic;
   bool noDynamicLinker = false;
   bool noinhibitExec;
   bool nostdlib;
   bool oFormatBinary;
   bool omagic;
+  bool opaquePointers;
   bool optEB = false;
   bool optEL = false;
   bool optimizeBBJumps;
   bool optRemarksWithHotness;
   bool picThunk;
   bool pie;
   bool printGcSections;
   bool printIcfSections;

lld/ELF/Driver.cpp

config->mergeArmExidx =
       args.hasFlag(OPT_merge_exidx_entries, OPT_no_merge_exidx_entries, true);
   config->mmapOutputFile =
       args.hasFlag(OPT_mmap_output_file, OPT_no_mmap_output_file, true);
   config->nmagic = args.hasFlag(OPT_nmagic, OPT_no_nmagic, false);
   config->noinhibitExec = args.hasArg(OPT_noinhibit_exec);
   config->nostdlib = args.hasArg(OPT_nostdlib);
   config->oFormatBinary = isOutputFormatBinary(args);
   config->omagic = args.hasFlag(OPT_omagic, OPT_no_omagic, false);
+  config->opaquePointers = args.hasFlag(
+      OPT_plugin_opt_opaque_pointers, OPT_plugin_opt_no_opaque_pointers, true);
   config->optRemarksFilename = args.getLastArgValue(OPT_opt_remarks_filename);
   config->optStatsFilename = args.getLastArgValue(OPT_plugin_opt_stats_file);
 
   // Parse remarks hotness threshold. Valid value is either integer or 'auto'.
   if (auto *arg = args.getLastArg(OPT_opt_remarks_hotness_threshold)) {
     auto resultOrErr = remarks::parseHotnessThresholdOption(arg->getValue());
     if (!resultOrErr)
       error(arg->getSpelling() + ": invalid argument '" + arg->getValue() +

lld/ELF/LTO.cpp

static lto::Config createConfig() {
 
   c.TimeTraceEnabled = config->timeTraceEnabled;
   c.TimeTraceGranularity = config->timeTraceGranularity;
 
   c.CSIRProfile = std::string(config->ltoCSProfileFile);
   c.RunCSIRInstr = config->ltoCSProfileGenerate;
   c.PGOWarnMismatch = config->ltoPGOWarnMismatch;
 
+  c.OpaquePointers = config->opaquePointers;
+
   if (config->emitLLVM) {
     c.PostInternalizeModuleHook = [](size_t task, const Module &m) {
       if (std::unique_ptr<raw_fd_ostream> os =
               openLTOOutputFile(config->outputFile))
         WriteBitcodeToFile(m, *os, false);
       return false;
     };
   }

lld/ELF/Options.td

 defm oformat: EEq<"oformat", "Specify the binary format for the output object file">,
   MetaVarName<"[elf,binary]">;
 
 def omagic: FF<"omagic">, MetaVarName<"<magic>">,
   HelpText<"Set the text and data sections to be readable and writable, do not page align sections, link against static libraries">;
 
 defm orphan_handling:
   Eq<"orphan-handling", "Control how orphan sections are handled when linker script used">;
 
 defm pack_dyn_relocs:
   EEq<"pack-dyn-relocs", "Pack dynamic relocations in the given format">,
   MetaVarName<"[none,android,relr,android+relr]">;
 
 defm use_android_relr_tags: BB<"use-android-relr-tags",
     "Use SHT_ANDROID_RELR / DT_ANDROID_RELR* tags instead of SHT_RELR / DT_RELR*",
     "Use SHT_RELR / DT_RELR* tags (default)">;
 
def: F<"plugin-opt=new-pass-manager">,
   Alias<no_lto_legacy_pass_manager>, HelpText<"Alias for --no-lto-legacy-pass-manager">;
 def: F<"plugin-opt=cs-profile-generate">,
   Alias<lto_cs_profile_generate>, HelpText<"Alias for --lto-cs-profile-generate">;
 def: J<"plugin-opt=cs-profile-path=">,
   Alias<lto_cs_profile_file>, HelpText<"Alias for --lto-cs-profile-file">;
 def: J<"plugin-opt=obj-path=">,
   Alias<lto_obj_path_eq>,
   HelpText<"Alias for --lto-obj-path=">;
+def plugin_opt_opaque_pointers: F<"plugin-opt=opaque-pointers">,
+  HelpText<"Use opaque pointers in IR during LTO (default)">;
+def plugin_opt_no_opaque_pointers: F<"plugin-opt=no-opaque-pointers">,
+  HelpText<"Use typed pointers in IR during LTO">;
 def: J<"plugin-opt=opt-remarks-filename=">,
   Alias<opt_remarks_filename>,
   HelpText<"Alias for --opt-remarks-filename">;
 def: J<"plugin-opt=opt-remarks-passes=">,
   Alias<opt_remarks_passes>,
   HelpText<"Alias for --opt-remarks-passes">;
 def: J<"plugin-opt=opt-remarks-format=">,
   Alias<opt_remarks_format>,

lld/test/ELF/lto/discard-value-names.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 
 ; RUN: ld.lld -shared -save-temps %t.o -o %t2.o
 ; RUN: llvm-dis < %t2.o.0.0.preopt.bc | FileCheck %s
 
 ; CHECK: @GlobalValueName
 ; CHECK: @foo(i32 %in)
 ; CHECK: somelabel:
-; CHECK:  %GV = load i32, i32* @GlobalValueName
+; CHECK:  %GV = load i32, ptr @GlobalValueName
 ; CHECK:  %add = add i32 %in, %GV
 ; CHECK:  ret i32 %add
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @GlobalValueName = global i32 0
 
 define i32 @foo(i32 %in) {
 somelabel:
   %GV = load i32, i32* @GlobalValueName
   %add = add i32 %in, %GV
   ret i32 %add
 }

lld/test/ELF/lto/ltopasses-basic.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: ld.lld %t.o -o %t.so -save-temps -mllvm -debug-pass=Arguments -shared 2>&1 | FileCheck %s --check-prefix=MLLVM
 ; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @ctor, i8* null }]
 define void @ctor() {
   ret void
 }
 
 ; `@ctor` doesn't do anything and so the optimizer should kill it, leaving no ctors
-; CHECK: @llvm.global_ctors = appending global [0 x { i32, void ()*, i8* }] zeroinitializer
+; CHECK: @llvm.global_ctors = appending global [0 x { i32, ptr, ptr }] zeroinitializer
 
 ; MLLVM: Pass Arguments:

lld/test/ELF/lto/type-merge.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-as %p/Inputs/type-merge.ll -o %t2.o
 ; RUN: ld.lld %t.o %t2.o -o %t -shared -save-temps
 ; RUN: llvm-dis < %t.0.0.preopt.bc | FileCheck %s
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @foo()  {
   call void @bar(i8* null)
   ret void
 }
 declare void @bar(i8*)
 
 ; CHECK:      define void @foo() {
-; CHECK-NEXT:   call void @bar(i8* null)
+; CHECK-NEXT:   call void @bar(ptr null)
 ; CHECK-NEXT:   ret void
 ; CHECK-NEXT: }
 
-; CHECK: declare void @bar(i8*)
+; CHECK: declare void @bar(ptr)
 
 ; CHECK:      define void @zed() {
-; CHECK-NEXT:   call void bitcast (void (i8*)* @bar to void ()*)()
+; CHECK-NEXT:   call void @bar()
 ; CHECK-NEXT:   ret void
 ; CHECK-NEXT: }

lld/test/ELF/lto/type-merge2.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-as %p/Inputs/type-merge2.ll -o %t2.o
 ; RUN: ld.lld %t.o %t2.o -o %t.so -shared -save-temps
 ; RUN: llvm-dis %t.so.0.0.preopt.bc -o - | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 
 %zed = type { i8 }
 define void @foo()  {
   call void @bar(%zed* null)
   ret void
 }
 declare void @bar(%zed*)
 
-; CHECK:      %zed = type { i8 }
-; CHECK-NEXT: %zed.0 = type { i16 }
-
 ; CHECK:      define void @foo() {
-; CHECK-NEXT:   call void bitcast (void (%zed.0*)* @bar to void (%zed*)*)(%zed* null)
+; CHECK-NEXT:   call void @bar(ptr null)
 ; CHECK-NEXT:   ret void
 ; CHECK-NEXT: }
 
-; CHECK:      define void @bar(%zed.0* %this) {
-; CHECK-NEXT:   store %zed.0* %this, %zed.0** null
+; CHECK:      define void @bar(ptr %this) {
+; CHECK-NEXT:   store ptr %this, ptr null
 ; CHECK-NEXT:   ret void
 ; CHECK-NEXT: }

lld/test/ELF/lto/wrap-unreferenced-before-codegen.test

 # UNWIND-DYNSYM:      NOTYPE  LOCAL  DEFAULT   UND
 # UNWIND-DYNSYM-NEXT: NOTYPE  GLOBAL DEFAULT   UND throw
 # UNWIND-DYNSYM-NEXT: NOTYPE  GLOBAL DEFAULT   UND __wrap__Unwind_Resume
 # UNWIND-DYNSYM-NEXT: FUNC    GLOBAL DEFAULT     9 _Z1fv
 
 # RUN: llvm-mc -triple x86_64-elf -filetype=obj -o %t/malloc.o %t/malloc.s
 # RUN: ld.lld -shared -o %t/libmalloc.so -soname libmalloc.so %t/malloc.o
 # RUN: llvm-mc -triple x86_64-elf -filetype=obj -o %t/emutls.o %t/emutls.s
-# RUN: llvm-as -o %t/usetls.bc %t/usetls.ll
-# RUN: ld.lld -shared -o %t/libusetls.so %t/usetls.bc %t/libmalloc.so \
+# RUN: llvm-as -opaque-pointers=1 -o %t/usetls.bc %t/usetls.ll
+# RUN: ld.lld --plugin-opt=opaque-pointers -shared -o %t/libusetls.so \
+# RUN:   %t/usetls.bc %t/libmalloc.so \
 # RUN:   --start-lib %t/emutls.o -mllvm -emulated-tls --wrap malloc
 # RUN: llvm-objdump --dynamic-reloc --disassemble %t/libusetls.so | \
 # RUN:   FileCheck --check-prefix=USETLS-DISASM %s
 # RUN: llvm-readelf --dyn-syms %t/libusetls.so | \
 # RUN:   FileCheck --check-prefix=USETLS-DYNSYM %s
 
 # USETLS-DISASM:       [[#%x,RELOC:]] R_X86_64_JUMP_SLOT __wrap_malloc
 # USETLS-DISASM-LABEL: <__emutls_get_address>:

llvm/docs/OpaquePointers.rst

 
 During the transition phase, LLVM can be used in two modes: In typed pointer
 mode (currently still the default) all pointer types have a pointee type and
 opaque pointers cannot be used. In opaque pointers mode, all pointers are
 opaque. The opaque pointer mode can be enabled using ``-opaque-pointers`` in
 LLVM tools like ``opt``, or ``-Xclang -opaque-pointers`` in clang. Additionally,
 opaque pointer mode is automatically enabled for IR and bitcode files that use
 the ``ptr`` type.
 
 In opaque pointer mode, all typed pointers used in IR, bitcode, or created
 using ``PointerType::get()`` and similar APIs are automatically converted into
 opaque pointers. This simplifies migration and allows testing existing IR with
 opaque pointers.
 
 .. code-block:: llvm
 
    define i8* @test(i8* %p) {

 For users of the clang driver interface, it is possible to temporarily restore
 the old default using the ``-DCLANG_ENABLE_OPAQUE_POINTERS=OFF`` cmake option,
 or by passing ``-Xclang -no-opaque-pointers`` to a single clang invocation.
 
 For users of the clang cc1 interface, ``-no-opaque-pointers`` can be passed.
 Note that the ``CLANG_ENABLE_OPAQUE_POINTERS`` cmake option has no effect on
 the cc1 interface.
 
+Usage for LTO can be disabled by passing ``-Wl,-plugin-opt=no-opaque-pointers``
+to the clang driver.
+
 The next steps for the opaque pointer migration are:
 
 * Migrate Clang/LLVM tests to use opaque pointers.
 * Enable opaque pointers by default in LLVM.
 * Remove support for typed pointers after the LLVM 15 branch has been created.

llvm/include/llvm/LTO/Config.h

struct Config {
   unsigned TimeTraceGranularity = 500;
 
   bool ShouldDiscardValueNames = true;
   DiagnosticHandlerFunction DiagHandler;
 
   /// Add FSAFDO discriminators.
   bool AddFSDiscriminator = false;
 
+  /// Use opaque pointer types. Used to call LLVMContext::setOpaquePointers
+  /// unless already set by the `-opaque-pointers` commandline option.
+  bool OpaquePointers = true;
+
   /// If this field is set, LTO will write input file paths and symbol
   /// resolutions here in llvm-lto2 command line flag format. This can be
   /// used for testing and for running the LTO pipeline outside of the linker
   /// with llvm-lto2.
   std::unique_ptr<raw_ostream> ResolutionFile;
 
   /// Tunable parameters for passes in the default pipelines.
   PipelineTuningOptions PTO;

 // FIXME: This should not be required as diagnostic handler is not callback.
 struct LTOLLVMContext : LLVMContext {
 
   LTOLLVMContext(const Config &C) : DiagHandler(C.DiagHandler) {
     setDiscardValueNames(C.ShouldDiscardValueNames);
     enableDebugTypeODRUniquing();
     setDiagnosticHandler(
         std::make_unique<LTOLLVMDiagnosticHandler>(&DiagHandler), true);
+    if (!hasSetOpaquePointersValue())
+      setOpaquePointers(C.OpaquePointers);
   }
   DiagnosticHandlerFunction DiagHandler;
 };
 
 }
 }
 
 #endif

llvm/test/Analysis/StackSafetyAnalysis/ipa-alias.ll

 ; RUN:  -r %t.summ1.bc,AliasToBitcastAliasWrite1,px \
 ; RUN:  -r %t.summ1.bc,AliasToPreemptableAliasWrite1,px \
 ; RUN:  -r %t.summ1.bc,AliasWrite1,px \
 ; RUN:  -r %t.summ1.bc,BitcastAliasWrite1,px \
 ; RUN:  -r %t.summ1.bc,InterposableAliasWrite1,px \
 ; RUN:  -r %t.summ1.bc,PreemptableAliasWrite1,px \
 ; RUN:  -r %t.summ1.bc,Write1,px
 
-; RUN: llvm-lto2 run %t.summ0.bc %t.summ1.bc -o %t.lto -stack-safety-print -stack-safety-run -save-temps -thinlto-threads 1 -O0 \
+; RUN: llvm-lto2 run -opaque-pointers=0 %t.summ0.bc %t.summ1.bc -o %t.lto -stack-safety-print -stack-safety-run -save-temps -thinlto-threads 1 -O0 \
 ; RUN:  $(cat %t.res.txt) \
 ; RUN:    2>&1 | FileCheck %s --check-prefixes=CHECK,GLOBAL,LTO
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64-unknown-linux"
 
 attributes #0 = { noinline sanitize_memtag "target-features"="+mte,+neon" }
 

llvm/test/Analysis/StackSafetyAnalysis/ipa.ll

 ; RUN:  -r %t.summ1.bc,Write1Private,px \
 ; RUN:  -r %t.summ1.bc,Write1SameModule,px \
 ; RUN:  -r %t.summ1.bc,Write1Weak,px \
 ; RUN:  -r %t.summ1.bc,Write4_2,px \
 ; RUN:  -r %t.summ1.bc,Write4,px \
 ; RUN:  -r %t.summ1.bc,Write8,px \
 ; RUN:  -r %t.summ1.bc,WriteAndReturn8,px
 
-; RUN: llvm-lto2 run %t.summ0.bc %t.summ1.bc -o %t.lto -stack-safety-print -stack-safety-run -save-temps -thinlto-threads 1 -O0 \
+; RUN: llvm-lto2 run -opaque-pointers=0 %t.summ0.bc %t.summ1.bc -o %t.lto -stack-safety-print -stack-safety-run -save-temps -thinlto-threads 1 -O0 \
 ; RUN:  $(cat %t.res.txt) \
 ; RUN:    2>&1 | FileCheck %s --check-prefixes=CHECK,GLOBAL,LTO
 
 ; RUN: llvm-lto2 run %t.summ0.bc %t.summ1.bc -o %t.lto -stack-safety-run -thinlto-distributed-indexes -thinlto-threads 1 -O0 $(cat %t.res.txt)
 ; RUN: (cat %t.ids.txt ; llvm-dis %t.summ1.bc.thinlto.bc -o -) | FileCheck --check-prefixes=INDEX %s
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64-unknown-linux"

llvm/test/LTO/Resolution/X86/alias-alias.ll

 ; RUN: llvm-as %s -o %t1.o
 ; RUN: llvm-as %p/Inputs/alias-alias-1.ll -o %t2.o
 ; RUN: llvm-lto2 run -o %t3.o %t1.o %t2.o -r %t2.o,a, -r %t2.o,d,px -r %t1.o,a,p -r %t1.o,c,p -r %t1.o,b -save-temps
 ; RUN: llvm-dis < %t3.o.0.0.preopt.bc -o - | FileCheck %s
 ; RUN: FileCheck --check-prefix=RES %s < %t3.o.resolution.txt
 
 ; CHECK-NOT: alias
 ; CHECK: @c = global i32 1
-; CHECK-NEXT: @d = global i32* @a
+; CHECK-NEXT: @d = global ptr @a
 ; CHECK-EMPTY:
-; CHECK-NEXT: @a = weak alias i32, i32* @b
-; CHECK-NEXT: @b = internal alias i32, i32* @c
+; CHECK-NEXT: @a = weak alias i32, ptr @b
+; CHECK-NEXT: @b = internal alias i32, ptr @c
 
 ; RES: 1.o{{$}}
 ; RES-NEXT: {{^}}-r={{.*}}1.o,c,p{{$}}
 ; RES-NEXT: {{^}}-r={{.*}}1.o,a,p{{$}}
 ; RES-NEXT: {{^}}-r={{.*}}1.o,b,{{$}}
 ; RES-NEXT: 2.o{{$}}
 ; RES-NEXT: {{^}}-r={{.*}}2.o,a,{{$}}
 ; RES-NEXT: {{^}}-r={{.*}}2.o,d,px{{$}}
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @a = weak alias i32, i32* @b
 @b = alias i32, i32* @c
 @c = global i32 1

llvm/test/LTO/Resolution/X86/comdat.ll

 @a14 = alias i16, bitcast (i32 (i8*)* @f1 to i16*)
 @a15 = alias i16, i16* @a14
 
 ; CHECK: $c1 = comdat any
 ; CHECK: $c2 = comdat any
 
 ; CHECK-DAG: @v1 = weak_odr global i32 42, comdat($c1)
 
-; CHECK-DAG: @r11 = global i32* @v1{{$}}
-; CHECK-DAG: @r12 = global i32 (i8*)* @f1{{$}}
+; CHECK-DAG: @r11 = global ptr @v1{{$}}
+; CHECK-DAG: @r12 = global ptr @f1{{$}}
 
-; CHECK-DAG: @r21 = global i32* @v1{{$}}
-; CHECK-DAG: @r22 = global i32 (i8*)* @f1{{$}}
+; CHECK-DAG: @r21 = global ptr @v1{{$}}
+; CHECK-DAG: @r22 = global ptr @f1{{$}}
 
 ; CHECK-DAG: @v1.1 = internal global i32 41, comdat($c2)
 
-; CHECK-DAG: @a11 = alias i32, i32* @v1{{$}}
-; CHECK-DAG: @a12 = alias i16, bitcast (i32* @v1 to i16*)
+; CHECK-DAG: @a11 = alias i32, ptr @v1{{$}}
+; CHECK-DAG: @a12 = alias i16, ptr @v1{{$}}
 
-; CHECK-DAG: @a13 = alias i32 (i8*), i32 (i8*)* @f1{{$}}
-; CHECK-DAG: @a14 = alias i16, bitcast (i32 (i8*)* @f1 to i16*)
+; CHECK-DAG: @a13 = alias i32 (ptr), ptr @f1{{$}}
+; CHECK-DAG: @a14 = alias i16, ptr @f1{{$}}
 
-; CHECK-DAG: @a21 = alias i32, i32* @v1.1{{$}}
-; CHECK-DAG: @a22 = alias i16, bitcast (i32* @v1.1 to i16*)
+; CHECK-DAG: @a21 = alias i32, ptr @v1.1{{$}}
+; CHECK-DAG: @a22 = alias i16, ptr @v1.1{{$}}
 
-; CHECK-DAG: @a23 = alias i32 (i8*), i32 (i8*)* @f1.2{{$}}
-; CHECK-DAG: @a24 = alias i16, bitcast (i32 (i8*)* @f1.2 to i16*)
+; CHECK-DAG: @a23 = alias i32 (ptr), ptr @f1.2{{$}}
+; CHECK-DAG: @a24 = alias i16, ptr @f1.2{{$}}
 
-; CHECK:      define weak_odr dso_local i32 @f1(i8* %0) comdat($c1) {
+; CHECK:      define weak_odr dso_local i32 @f1(ptr %0) comdat($c1) {
 ; CHECK-NEXT: bb10:
 ; CHECK-NEXT:   br label %bb11{{$}}
 ; CHECK:      bb11:
 ; CHECK-NEXT:   ret i32 42
 ; CHECK-NEXT: }
 
-; CHECK:      define internal i32 @f1.2(i8* %this) comdat($c2) {
+; CHECK:      define internal i32 @f1.2(ptr %this) comdat($c2) {
 ; CHECK-NEXT: bb20:
-; CHECK-NEXT:   store i8* %this, i8** null
+; CHECK-NEXT:   store ptr %this, ptr null
 ; CHECK-NEXT:   br label %bb21
 ; CHECK:      bb21:
 ; CHECK-NEXT:   ret i32 41
 ; CHECK-NEXT: }

llvm/test/LTO/Resolution/X86/ifunc2.ll

 ; RUN: llvm-as -o %t1.o %s
 ; RUN: llvm-as -o %t2.o %S/Inputs/ifunc2.ll
 ; RUN: llvm-lto2 run %t1.o %t2.o -r %t1.o,foo,p -r %t1.o,foo_resolver, -r %t2.o,foo_resolver,p -save-temps -o %t3.o
 ; RUN: llvm-dis -o - %t3.o.0.0.preopt.bc | FileCheck %s
 
 target datalayout = "e-p:64:64"
 target triple = "x86_64-unknown-linux-gnu"
 
-; CHECK: @foo = ifunc i32 (), i32 ()* ()* @foo_resolver.2
+; CHECK: @foo = ifunc i32 (), ptr @foo_resolver.2
 @foo = ifunc i32 (), i32 ()* ()* @foo_resolver
 
-; CHECK: define internal i32 ()* @foo_resolver.2() {
-; CHECK-NEXT: ret i32 ()* inttoptr (i32 1 to i32 ()*)
+; CHECK: define internal ptr @foo_resolver.2() {
+; CHECK-NEXT: ret ptr inttoptr (i32 1 to ptr)
 define weak i32 ()* @foo_resolver() {
   ret i32 ()* inttoptr (i32 1 to i32 ()*)
 }
 
-; CHECK: define i32 ()* @foo_resolver() {
-; CHECK-NEXT: ret i32 ()* inttoptr (i32 2 to i32 ()*)
+; CHECK: define ptr @foo_resolver() {
+; CHECK-NEXT: ret ptr inttoptr (i32 2 to ptr)

llvm/test/LTO/Resolution/X86/local-def-dllimport.ll

 ; RUN: opt -thinlto-bc -thinlto-split-lto-unit -o %t0.bc %s
 ; RUN: llvm-lto2 run -r %t0.bc,__imp_f,l \
 ; RUN:               -r %t0.bc,g,p \
 ; RUN:               -r %t0.bc,g,l \
 ; RUN:               -r %t0.bc,e,l \
 ; RUN:               -r %t0.bc,main,x \
 ; RUN:               -save-temps -o %t1 %t0.bc
 ; RUN: llvm-dis %t1.1.3.import.bc -o - | FileCheck %s
 source_filename = "test.cpp"
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 $g = comdat any
 @g = global i8 42, comdat, !type !0
 
-; CHECK: define available_externally dllimport i8* @f()
+; CHECK: define available_externally dllimport ptr @f()
 define available_externally dllimport i8* @f() {
   ret i8* @g
 }
 
 define i8* @e() {
   ret i8* @g
 }
 
 define i32 @main() {
   %1 = call i8* @f()
   %2 = ptrtoint i8* %1 to i32
   ret i32 %2
 }
 !0 = !{i32 0, !"typeid"}

llvm/test/LTO/X86/Inputs/opaque-pointers.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+define i64 @foo(ptr %p) {
+  %t = load i64, ptr %p
+  ret i64 %t
+}

llvm/test/LTO/X86/cfi_jt_aliases.ll

 ; CHECK-THIN-OD-NEXT: R_X86_64_PLT32 b
 ; CHECK-THIN-OD:      c.cfi_jt>:
 ; CHECK-THIN-OD:      jmp {{.*}} <c.cfi_jt
 ; CHECK-THIN-OD-NEXT: R_X86_64_PLT32 c
 ; CHECK-THIN-OD:      a.cfi_jt>:
 ; CHECK-THIN-OD:      jmp {{.*}} <a.cfi_jt
 ; CHECK-THIN-OD-NEXT: R_X86_64_PLT32 a
 
-; CHECK-USED: @llvm.used = appending global [3 x i8*] [i8* bitcast (void ()* @a.cfi_jt to i8*), i8* bitcast (void ()* @b.cfi_jt to i8*), i8* bitcast (void ()* @c.cfi_jt to i8*)], section "llvm.metadata"
+; CHECK-USED: @llvm.used = appending global [3 x ptr] [ptr @a.cfi_jt, ptr @b.cfi_jt, ptr @c.cfi_jt], section "llvm.metadata"
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @f = internal global [4 x void ()*] [void ()* @a, void ()* @b, void ()* @c, void ()* null], align 16
 
 define dso_local void @a() !type !5 !type !6 { ret void }
 define dso_local void @b() !type !5 !type !6 { ret void }

llvm/test/LTO/X86/mix-opaque-typed.ll

+; RUN: llvm-as -opaque-pointers=0 %s -o %t-typed.bc
+; RUN: llvm-as -opaque-pointers=1 %S/Inputs/opaque-pointers.ll -o %t-opaque.bc
+; RUN: llvm-lto2 run -o %t-lto.bc %t-typed.bc %t-opaque.bc -save-temps \
+; RUN:     -lto-opaque-pointers \
+; RUN:     -r %t-typed.bc,call_foo,px -r %t-typed.bc,foo,l \
+; RUN:     -r %t-opaque.bc,foo,px
+; RUN: opt -S -o - %t-lto.bc.0.4.opt.bc | FileCheck %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+declare i64 @foo(i64* %p);
+
+define i64 @call_foo(i64* %p) {
+  ; CHECK-LABEL: define i64 @call_foo(ptr nocapture readonly %p) local_unnamed_addr #0 {
+  ; CHECK-NEXT: %t.i = load i64, ptr %p, align 8
+  %t = call i64 @foo(i64* %p)
+  ret i64 %t
+}

llvm/test/LTO/X86/type-mapping-bug4.ll

 ; RUN: opt -module-summary -o %t0.o %S/Inputs/type-mapping-bug4_0.ll
 ; RUN: opt -module-summary -o %t1.o %S/Inputs/type-mapping-bug4_1.ll
 ; RUN: opt -module-summary -o %t2.o %s
 ; RUN: llvm-lto2 run -save-temps -o %t3 %t0.o %t1.o %t2.o -r %t1.o,a,px -r %t2.o,d,px -r %t1.o,h,x -r %t2.o,h,x -r %t1.o,j,px
 ; RUN: llvm-dis < %t3.0.0.preopt.bc | FileCheck %s
 
 ; stage0: linking t0.o
 ; stage1: linking t1.o
 ; stage2: during linking t1.o, mapping @d
 ; stage3: linking t2.o
 
 ; Stage0 is not described because it is not interesting for the purpose of this test.
 ; Stage1 and stage2 are described in type-mapping-bug4_1.ll.
 ; Stage3 is described in this file.
 
-; CHECK: %class.CCSM = type opaque
-; CHECK: %class.CB = type { %"class.std::unique_ptr_base.1" }
-; CHECK: %"class.std::unique_ptr_base.1" = type { %class.CCSM* }
+; CHECK: %class.CB.1 = type { %"class.std::unique_ptr_base.2" }
+; CHECK: %"class.std::unique_ptr_base.2" = type { ptr }
 
 ; CHECK: define void @j() {
-; CHECK:   call void @h(%class.CCSM* undef)
+; CHECK:   call void @h(ptr undef)
 ; CHECK:   ret void
 ; CHECK: }
 
-; CHECK: declare void @h(%class.CCSM*)
+; CHECK: declare void @h(ptr)
 
 ; CHECK: define void @a() {
-; CHECK:   call void @llvm.dbg.value(metadata %class.CB* undef, metadata !10, metadata !DIExpression())
+; CHECK:   call void @llvm.dbg.value(metadata ptr undef, metadata !10, metadata !DIExpression())
 ; CHECK:   ret void
 ; CHECK: }
 
 ; CHECK: declare void @llvm.dbg.value(metadata, metadata, metadata) #0
 
-; CHECK: define void @d(%class.CB* %0) {
-; CHECK:   %2 = getelementptr inbounds %class.CB, %class.CB* undef, i64 0, i32 0, i32 0
+; CHECK: define void @d(ptr %0) {
+; CHECK:   %2 = getelementptr inbounds %class.CB.1, ptr undef, i64 0, i32 0, i32 0
 ; CHECK:   ret void
 ; CHECK: }
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; (stage3) Remapping this type returns itself due to D47898 and stage1.3
 %class.CB = type { %"class.std::unique_ptr_base.2" }

llvm/test/ThinLTO/X86/Inputs/import-constant.ll

 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 %struct.S = type { i32, i32, i32* }
 %struct.Q = type { %struct.S* }
 
 @val = dso_local global i32 42, align 4
 @_ZL3Obj = internal constant %struct.S { i32 4, i32 8, i32* @val }, align 8
 @outer = dso_local local_unnamed_addr global %struct.Q { %struct.S* @_ZL3Obj }, align 8
 
 define dso_local nonnull %struct.S* @_Z6getObjv() local_unnamed_addr {
 entry:
-  store %struct.S* null, %struct.S** getelementptr inbounds (%struct.Q, %struct.Q* @outer, i64 0, i32 0), align 8
+  store %struct.S* null, %struct.S** getelementptr inbounds (%struct.Q, %struct.Q* @outer, i64 1, i32 0), align 8
   ret %struct.S* @_ZL3Obj
 }

llvm/test/ThinLTO/X86/cfi-devirt.ll

cont2:
   %7 = extractvalue { i8*, i1 } %5, 0
   %8 = bitcast i8* %7 to i32 (%struct.A*, i32)*
 
   ; Check that traps are conditional. Invalid TYPE_ID can cause
   ; unconditional traps.
   ; CHECK-IR: br i1 {{.*}}, label %trap, label %cont2
 
   ; We still have to call it as virtual.
-  ; CHECK-IR: %call3 = tail call i32 %7
+  ; CHECK-IR: %call3 = tail call i32 %5
   %call3 = tail call i32 %8(%struct.A* nonnull %obj, i32 %call)
   ret i32 %call3
 }
 ; CHECK-IR-LABEL: ret i32
 ; CHECK-IR-LABEL: }
 
 declare { i8*, i1 } @llvm.type.checked.load(i8*, i32, metadata)
 declare void @llvm.trap()
 
 declare i32 @_ZN1B1fEi(%struct.B* %this, i32 %a)
 declare i32 @_ZN1A1nEi(%struct.A* %this, i32 %a)
 declare i32 @_ZN1C1fEi(%struct.C* %this, i32 %a)
 
 !0 = !{i64 16, !"_ZTS1A"}
 !1 = !{i64 16, !"_ZTS1B"}
 !2 = !{i64 16, !"_ZTS1C"}

llvm/test/ThinLTO/X86/cfi-unsat.ll

cont:
 
   %call = tail call i32 %4(%struct.A* nonnull %obj, i32 %a)
 
   ret i32 %call
 }
 
 ; CHECK-IR0: define weak_odr i32 @test
 ; CHECK-IR0-NEXT: entry:
-; CHECK-IR0-NEXT: %0 = bitcast
 ; CHECK-IR0-NEXT: %vtable5 =
 ; CHECK-IR0-NEXT: tail call void @llvm.trap()
 ; CHECK-IR0-NEXT: unreachable
 ; CHECK-IR0-NEXT: }
 ; CHECK-IR0: define weak_odr i32 @testb
 ; CHECK-IR0-NEXT: entry:
-; CHECK-IR0-NEXT: %0 = bitcast
 ; CHECK-IR0-NEXT: %vtable5 =
 ; CHECK-IR0-NEXT: tail call void @llvm.trap()
 ; CHECK-IR0-NEXT: unreachable
 ; CHECK-IR0-NEXT: }
 
 ; CHECK-IR1: define weak_odr i32 @test2
 ; CHECK-IR1-NEXT:   entry:
 ; CHECK-IR1-NEXT:     tail call void @llvm.trap()
 ; CHECK-IR1-NEXT:     unreachable
 ; CHECK-IR1-NEXT:   }
 
 declare { i8*, i1 } @llvm.type.checked.load(i8*, i32, metadata)
 declare void @llvm.trap()

llvm/test/ThinLTO/X86/devirt-after-icp.ll

if.true.direct_targ:                              ; preds = %entry
   %6 = bitcast i32 (%class.A*)** %vtable to i8*
   %7 = tail call i1 @llvm.type.test(i8* %6, metadata !"_ZTS1B")
   tail call void @llvm.assume(i1 %7)
   %vfn.i1 = getelementptr inbounds i32 (%class.A*)*, i32 (%class.A*)** %vtable, i64 1
   %vfn.i = bitcast i32 (%class.A*)** %vfn.i1 to i32 (%class.B*)**
   %8 = load i32 (%class.B*)*, i32 (%class.B*)** %vfn.i, align 8
 ; Call to bar() can be devirtualized to call to B::bar(), since it was
 ; inlined from B::foo() after ICP introduced the guarded promotion.
-; CHECK-IR: %call.i = tail call i32 @_ZN1B3barEv(%class.B* %3)
+; CHECK-IR: %call.i = tail call i32 @_ZN1B3barEv(ptr nonnull %a)
   %call.i = tail call i32 %8(%class.B* %5)
   br label %if.end.icp
 
 ; This block contains the fallback indirect call a->foo()
 ; CHECK-IR: if.false.orig_indirect:
 if.false.orig_indirect:                           ; preds = %entry
 ; Fallback indirect call to foo() cannot be devirtualized.
 ; CHECK-IR: %call = tail call i32 %

llvm/test/ThinLTO/X86/devirt2.ll

entry:
   call void @llvm.assume(i1 %p)
   %fptrptr = getelementptr i8*, i8** %vtable, i32 1
   %2 = bitcast i8** %fptrptr to i32 (%struct.A*, i32)**
   %fptr1 = load i32 (%struct.A*, i32)*, i32 (%struct.A*, i32)** %2, align 8
 
   ; Check that the call was devirtualized. Ignore extra character before
   ; symbol name which would happen if it was promoted during module
   ; splitting for hybrid WPD.
-  ; CHECK-IR1: %call = tail call i32 bitcast (void ()* @{{.*}}_ZN1A1nEi
+  ; CHECK-IR1: %call = tail call i32 @_ZN1A1nEi
   %call = tail call i32 %fptr1(%struct.A* nonnull %obj, i32 %a)
 
   %3 = bitcast i8** %vtable to i32 (%struct.A*, i32)**
   %fptr22 = load i32 (%struct.A*, i32)*, i32 (%struct.A*, i32)** %3, align 8
 
   ; We still have to call it as virtual.
   ; CHECK-IR1: %call3 = tail call i32 %fptr22
   %call3 = tail call i32 %fptr22(%struct.A* nonnull %obj, i32 %call)

llvm/test/ThinLTO/X86/devirt_check.ll

entry:
   %p = call i1 @llvm.type.test(i8* %1, metadata !"_ZTS1A")
   call void @llvm.assume(i1 %p)
   %fptrptr = getelementptr i8*, i8** %vtable, i32 1
   %2 = bitcast i8** %fptrptr to i32 (%struct.A*, i32)**
   %fptr1 = load i32 (%struct.A*, i32)*, i32 (%struct.A*, i32)** %2, align 8
 
   ; Check that the call was devirtualized, but preceeded by a check guarding
   ; a trap if the function pointer doesn't match.
-  ; TRAP:   %.not = icmp eq i32 (%struct.A*, i32)* %fptr1, @_ZN1A1nEi
+  ; TRAP:   %.not = icmp eq ptr %fptr1, @_ZN1A1nEi
   ; Ensure !prof and !callees metadata for indirect call promotion removed.
   ; TRAP-NOT: prof
   ; TRAP-NOT: callees
-  ; TRAP:   br i1 %.not, label %3, label %2
-  ; TRAP: 2:
+  ; TRAP:   br i1 %.not, label %1, label %0
+  ; TRAP: 0:
   ; TRAP:   tail call void @llvm.debugtrap()
-  ; TRAP:   br label %3
-  ; TRAP: 3:
+  ; TRAP:   br label %1
+  ; TRAP: 1:
   ; TRAP:   tail call i32 @_ZN1A1nEi
   ; Check that the call was devirtualized, but preceeded by a check guarding
   ; a fallback if the function pointer doesn't match.
-  ; FALLBACK:   %2 = icmp eq i32 (%struct.A*, i32)* %fptr1, @_ZN1A1nEi
-  ; FALLBACK:   br i1 %2, label %if.true.direct_targ, label %if.false.orig_indirect
+  ; FALLBACK:   %0 = icmp eq ptr %fptr1, @_ZN1A1nEi
+  ; FALLBACK:   br i1 %0, label %if.true.direct_targ, label %if.false.orig_indirect
   ; FALLBACK: if.true.direct_targ:
   ; FALLBACK:   tail call i32 @_ZN1A1nEi
   ; Ensure !prof and !callees metadata for indirect call promotion removed.
   ; FALLBACK-NOT: prof
   ; FALLBACK-NOT: callees
   ; FALLBACK:   br label %if.end.icp
   ; FALLBACK: if.false.orig_indirect:
   ; FALLBACK:   tail call i32 %fptr1

llvm/test/ThinLTO/X86/devirt_promote.ll

entry:
   %1 = bitcast i8** %vtable to i8*
   %p = call i1 @llvm.type.test(i8* %1, metadata !"_ZTS1A")
   call void @llvm.assume(i1 %p)
   %fptrptr = getelementptr i8*, i8** %vtable, i32 1
   %2 = bitcast i8** %fptrptr to i32 (%struct.A*, i32)**
   %fptr1 = load i32 (%struct.A*, i32)*, i32 (%struct.A*, i32)** %2, align 8
 
   ; Check that the call was devirtualized.
-  ; CHECK-IR1: %call = tail call i32 bitcast (void ()* @_ZN1A1nEi
+  ; CHECK-IR1: %call = tail call i32 @_ZN1A1nEi
   %call = tail call i32 %fptr1(%struct.A* nonnull %obj, i32 %a)
 
   ret i32 %call
 }
 ; CHECK-IR1-LABEL: ret i32
 ; CHECK-IR1-LABEL: }
 
 ; CHECK-IR2: define i32 @test2
 ; Check that the call was devirtualized.
 ; CHECK-IR2:   %call4 = tail call i32 @_ZN1A1nEi
 
 declare i1 @llvm.type.test(i8*, metadata)
 declare void @llvm.assume(i1)
 
 attributes #0 = { noinline optnone }

llvm/test/ThinLTO/X86/devirt_single_hybrid.ll

 ; RUN:    -r=%t-bar.bc,_ZNK1A1fEv, \
 ; RUN:    -r=%t-bar.bc,_ZTV1A,pl \
 ; RUN:    -r=%t-bar.bc,_ZTI1A, 2>&1 | FileCheck %s --check-prefix=REMARK
 ; RUN: llvm-dis %t.1.3.import.bc -o - | FileCheck %s --check-prefix=IMPORT
 ; RUN: llvm-dis %t.1.5.precodegen.bc -o - | FileCheck %s --check-prefix=CODEGEN
 
 ; REMARK-COUNT-3: single-impl: devirtualized a call to _ZNK1A1fEv
 
-; IMPORT:       define available_externally hidden i32 @_ZNK1A1fEv(%struct.A* %this)
+; IMPORT:       define available_externally hidden i32 @_ZNK1A1fEv(ptr %this)
 ; IMPORT-NEXT:  entry:
 ; IMPORT-NEXT:      ret i32 3
 
 ; CODEGEN:        define hidden i32 @main()
 ; CODEGEN-NEXT:   entry:
 ; CODEGEN-NEXT:     ret i32 23
 
 ; Virtual method should have been optimized out

llvm/test/ThinLTO/X86/funcattrs-prop-unknown.ll

 ; Unknown (e.g. indirect) calls returns conservative results from function propagation
 ; RUN: opt -thinlto-bc %s -thin-link-bitcode-file=%t1.thinlink.bc -o %t1.bc
 ; RUN: llvm-lto2 run -disable-thinlto-funcattrs=0 %t1.bc -o %t.o -save-temps \
 ; RUN:    -r %t1.bc,indirect,px -r %t1.bc,inlineasm,px -r %t1.bc,selectcallee,px -r %t1.bc,f, -r %t1.bc,g, -r %t1.bc,global,
 ; RUN: llvm-dis -o - %t.o.1.3.import.bc | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK-NOT: ; Function Attrs:
-; CHECK: define i32 @indirect(i32 ()* nocapture %0) {
+; CHECK: define i32 @indirect(ptr nocapture %0) {
 define i32 @indirect(i32 ()* nocapture) {
   %2 = tail call i32 %0()
   ret i32 %2
 }
 
 ; CHECK-NOT: ; Function Attrs:
-; CHECK: define i8* @inlineasm() {
+; CHECK: define ptr @inlineasm() {
 define i8* @inlineasm() {
 entry:
   %0 = tail call i8* asm sideeffect "lea ff_h264_cabac_tables(%rip), $0", "=&r,~{dirflag},~{fpsr},~{flags}"()
   ret i8* %0
 }
 
 ; CHECK-NOT: ; Function Attrs:
 ; CHECK: define void @selectcallee() {
 define void @selectcallee() {
     ; Test calls that aren't handled either as direct or indirect.
     call void select (i1 icmp eq (i32* @global, i32* null), void ()* @f, void ()* @g)()
     ret void
 }
 
 declare void @f()
 declare void @g()
-@global = extern_weak global i32
+@global = extern_weak global i32
 

llvm/test/ThinLTO/X86/globals-import-blockaddr.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/globals-import-blockaddr.ll -o %t2.bc
 ; RUN: llvm-lto2 run -save-temps %t1.bc -r=%t1.bc,foo,l -r=%t1.bc,bar,l -r=%t1.bc,main,pl %t2.bc -r=%t2.bc,foo,pl -r=%t2.bc,bar,pl -o %t3
 ; RUN: llvm-dis %t3.1.3.import.bc -o - | FileCheck %s
 
 ; Verify that we haven't imported GV containing blockaddress
 ; CHECK: @label_addr.llvm.0 = external hidden constant
 ; Verify that bar is not imported since it has address-taken block that is target of indirect branch
-; CHECK: declare [1 x i8*]* @bar()
+; CHECK: declare ptr @bar()
 ; Verify that foo is imported
-; CHECK: available_externally [1 x i8*]* @foo
+; CHECK: available_externally ptr @foo
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare dso_local [1 x i8*]* @foo();
 declare dso_local [1 x i8*]* @bar();
 
 define dso_local i32 @main() {
   %p1 = call [1 x i8*]* @foo()
   %p2 = call [1 x i8*]* @bar()
   %v1 = ptrtoint [1 x i8*]* %p1 to i32
   %v2 = ptrtoint [1 x i8*]* %p2 to i32
   %v3 = add i32 %v1, %v2
   ret i32 %v3
 }

llvm/test/ThinLTO/X86/import-constant.ll

 ; RUN:    -r=%t1.bc,main,plx \
 ; RUN:    -r=%t1.bc,_Z6getObjv,l \
 ; RUN:    -r=%t2.bc,_Z6getObjv,pl \
 ; RUN:    -r=%t2.bc,val,pl \
 ; RUN:    -r=%t2.bc,outer,pl
 ; RUN: llvm-dis %t-out-norefs.1.3.import.bc -o - | FileCheck %s --check-prefix=NOREFS
 
 ; Check that variable has been promoted in the source module
-; PROMOTE: @_ZL3Obj.llvm.{{.*}} = hidden constant %struct.S { i32 4, i32 8, i32* @val }
+; PROMOTE: @_ZL3Obj.llvm.{{.*}} = hidden constant %struct.S { i32 4, i32 8, ptr @val }
 
 ; @outer is a write-only variable, so it's been converted to zeroinitializer.
 ; IMPORT:      @val = available_externally global i32 42
-; IMPORT-NEXT: @_ZL3Obj.llvm.{{.*}} = available_externally hidden constant %struct.S { i32 4, i32 8, i32* @val }
+; IMPORT-NEXT: @_ZL3Obj.llvm.{{.*}} = available_externally hidden constant %struct.S { i32 4, i32 8, ptr @val }
 ; IMPORT-NEXT: @outer = internal local_unnamed_addr global %struct.Q zeroinitializer
 
 ; OPT: @outer = internal unnamed_addr global %struct.Q zeroinitializer
 
 ; OPT:      define dso_local i32 @main()
 ; OPT-NEXT: entry:
-; OPT-NEXT:   store %struct.S* null, %struct.S** getelementptr inbounds (%struct.Q, %struct.Q* @outer, i64 0, i32 0)
+; OPT-NEXT:   store ptr null, ptr getelementptr inbounds (%struct.Q, ptr @outer, i64 1, i32 0)
 ; OPT-NEXT:   ret i32 12
 
 ; NOREFS:      @_ZL3Obj.llvm.{{.*}} = external hidden constant %struct.S
 ; NOREFS-NEXT: @outer = internal local_unnamed_addr global %struct.Q zeroinitializer
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 

llvm/test/ThinLTO/X86/import-dsolocal.ll

 ; RUN: llvm-lto2 run %t/a.bc %t/b.bc -o %t2 -save-temps -import-instr-limit=10 \
 ; RUN:   -r=%t/a.bc,main,plx -r=%t/a.bc,extern, -r=%t/a.bc,linkonce, -r=%t/a.bc,linkonceodr, -r=%t/a.bc,weak, -r=%t/a.bc,weakodr, \
 ; RUN:   -r=%t/b.bc,a,pl -r=%t/b.bc,b,pl -r=%t/b.bc,extern,pl -r=%t/b.bc,extern_aux,pl \
 ; RUN:   -r=%t/b.bc,linkonce,pl -r=%t/b.bc,linkonce_aux,pl -r=%t/b.bc,linkonceodr,pl -r=%t/b.bc,linkonceodr_aux,pl \
 ; RUN:   -r=%t/b.bc,weak,pl -r=%t/b.bc,weak_aux,pl -r=%t/b.bc,weakodr,pl -r=%t/b.bc,weakodr_aux,pl
 ; RUN: llvm-dis %t2.1.3.import.bc -o - | FileCheck %s --check-prefixes=DEST,DEST2
 
 ; DEST:      @a = available_externally global i32 42, align 4
-; DEST-NEXT: @b = external global i32*, align 8
+; DEST-NEXT: @b = external global ptr, align 8
 ; DEST:      declare void @linkonce()
 ; DEST:      declare void @weak()
 ; DEST:      define dso_local i32 @main()
 ; DEST:      define available_externally void @extern()
 
-; DEST1:     declare i32 @extern_aux(i32*, i32**)
-; DEST1:     declare i32 @linkonceodr_aux(i32*, i32**)
-; DEST2:     define available_externally i32 @extern_aux(i32* %a, i32** %b)
-; DEST2:     define available_externally i32 @linkonceodr_aux(i32* %a, i32** %b)
+; DEST1:     declare i32 @extern_aux(ptr, ptr)
+; DEST1:     declare i32 @linkonceodr_aux(ptr, ptr)
+; DEST2:     define available_externally i32 @extern_aux(ptr %a, ptr %b)
+; DEST2:     define available_externally i32 @linkonceodr_aux(ptr %a, ptr %b)
 
 ; DEST:      define available_externally void @weakodr()
 
-; DEST1:     declare i32 @weakodr_aux(i32*, i32**)
-; DEST2:     define available_externally i32 @weakodr_aux(i32* %a, i32** %b)
+; DEST1:     declare i32 @weakodr_aux(ptr, ptr)
+; DEST2:     define available_externally i32 @weakodr_aux(ptr %a, ptr %b)
 
 ;--- a.ll
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @extern()
 declare void @linkonce()
 declare void @linkonceodr()

llvm/test/ThinLTO/X86/index-const-prop-gvref-pie.ll

 ;; The same as index-const-prop-gvref.ll, except for PIE.
 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/index-const-prop-gvref.ll -o %t2.bc
 ; RUN: llvm-lto2 run -save-temps %t2.bc -r=%t2.bc,b,pl -r=%t2.bc,a,pl \
 ; RUN:   %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,a, -r=%t1.bc,b, -o %t3
 ; RUN: llvm-dis %t3.2.3.import.bc -o - | FileCheck %s --check-prefix=DEST
 
 ;; For PIE, keep dso_local for declarations to enable direct access.
-; DEST:      @b = external dso_local global i32*
+; DEST:      @b = external dso_local global ptr
 ; DEST-NEXT: @a = available_externally dso_local global i32 42, align 4
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @a = external global i32
 @b = external global i32*
 

llvm/test/ThinLTO/X86/index-const-prop-gvref.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/index-const-prop-gvref.ll -o %t2.bc
 ; RUN: llvm-lto2 run -relocation-model=static -save-temps %t2.bc -r=%t2.bc,b,pl -r=%t2.bc,a,pl \
 ; RUN:   %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,a, -r=%t1.bc,b, -o %t3
 ; RUN: llvm-dis %t3.1.3.import.bc -o - | FileCheck %s --check-prefix=SRC
 ; RUN: llvm-dis %t3.2.3.import.bc -o - | FileCheck %s --check-prefix=DEST
 
 ;; When producing an ELF DSO, clear dso_local for declarations to avoid direct access.
 ; RUN: llvm-lto2 run -relocation-model=pic -save-temps %t2.bc -r=%t2.bc,b,pl -r=%t2.bc,a,pl \
 ; RUN:   %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,a, -r=%t1.bc,b, -o %t4
 ; RUN: llvm-dis %t4.1.3.import.bc -o - | FileCheck %s --check-prefix=SRC
 ; RUN: llvm-dis %t4.2.3.import.bc -o - | FileCheck %s --check-prefix=DEST_DSO
 
 ; No variable in the source module should have been internalized
-; SRC:      @b = dso_local global i32* @a
+; SRC:      @b = dso_local global ptr @a
 ; SRC-NEXT: @a = dso_local global i32 42
 
 ; We can't internalize globals referenced by other live globals
-; DEST:          @b = external dso_local global i32*
+; DEST:          @b = external dso_local global ptr
 ; DEST-NEXT:     @a = available_externally dso_local global i32 42, align 4
-; DEST_DSO:      @b = external global i32*
+; DEST_DSO:      @b = external global ptr
 ; DEST_DSO-NEXT: @a = available_externally global i32 42, align 4
 
 ;; Test old API.
 ;; When producing an ELF DSO, clear dso_local for declarations to avoid direct access.
 ; RUN: llvm-lto -thinlto-action=run %t2.bc %t1.bc -relocation-model=static -thinlto-save-temps=%t5.
 ; RUN: llvm-dis < %t5.0.3.imported.bc | FileCheck %s --check-prefix=OLDAPI_SRC
 ; RUN: llvm-dis < %t5.1.3.imported.bc | FileCheck %s --check-prefix=OLDAPI_DST
 ; RUN: llvm-lto -thinlto-action=run %t2.bc %t1.bc -relocation-model=pic -thinlto-save-temps=%t6.

llvm/test/ThinLTO/X86/index-const-prop-linkage.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/index-const-prop-linkage.ll -o %t2.bc
 ; RUN: llvm-lto2 run -save-temps %t2.bc -r=%t2.bc,foo,pl -r=%t2.bc,g1,pl -r=%t2.bc,g2,pl -r=%t2.bc,g3, \
 ; RUN:                           %t1.bc -r=%t1.bc,foo, -r=%t1.bc,main,plx -r=%t1.bc,g2,  -o %t3
 ; RUN: llvm-dis %t3.2.3.import.bc -o - | FileCheck %s
 
 ; Check that we never internalize anything with:
 ; - appending linkage
 ; - common linkage
 ; - available_externally linkage
 ; - reference from @llvm.used
-; CHECK:      @llvm.used = appending global [1 x i32*] [i32* @g2]
+; CHECK:      @llvm.used = appending global [1 x ptr] [ptr @g2]
 ; CHECK-NEXT: @g1 = external global i32, align 4
 ; CHECK-NEXT: @g2 = available_externally global i32 42, align 4
 ; CHECK-NEXT: @g3 = available_externally global i32 42, align 4
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare i32 @foo()
 @g2 = external global i32
 @llvm.used = appending global [1 x i32*] [i32* @g2]
 
 define i32 @main() {
   %v = call i32 @foo()
   ret i32 %v
 }

llvm/test/ThinLTO/X86/reference_non_importable.ll

 ; RUN: llvm-dis < %t.o.1.2.internalize.bc | FileCheck  %s --check-prefix=PROMOTE
 ; PROMOTE: @a = private global i8 0, section "__TEXT,__cstring,cstring_literals"
 @a = private global i8 0, section "__TEXT,__cstring,cstring_literals"
 @b = global i8 *@a
 
 
 ; We want foo to be imported in the main module!
 ; RUN: llvm-dis < %t.o.2.3.import.bc  | FileCheck  %s --check-prefix=IMPORT
-; IMPORT: define available_externally dso_local i8** @foo()
+; IMPORT: define available_externally dso_local ptr @foo()
 define i8 **@foo() {
   ret i8 **@b
 }

llvm/test/ThinLTO/X86/weak_externals.ll

 ; Test that linkonce_odr and weak_odr variables which are visible to regular
 ; object (and so are not readonly) are not internalized by thin LTO.
 ; RUN: opt -module-summary %s -o %t.bc
 ; RUN: llvm-lto2 run -save-temps %t.bc -o %t.out \
 ; RUN:               -r=%t.bc,_ZL5initSv,plx \
 ; RUN:               -r=%t.bc,_ZN9SingletonI1SE11getInstanceEv,lx \
 ; RUN:               -r=%t.bc,_ZZN9SingletonI1SE11getInstanceEvE8instance,lx \
 ; RUN:               -r=%t.bc,_ZZN9SingletonI1SE11getInstanceEvE13instance_weak,lx
 ; RUN: llvm-dis %t.out.1.1.promote.bc -o - | FileCheck %s
 ; RUN: llvm-dis %t.out.1.2.internalize.bc -o - | FileCheck %s --check-prefix=INTERNALIZE
 
 ; CHECK: @_ZZN9SingletonI1SE11getInstanceEvE8instance = available_externally dso_local global %struct.S zeroinitializer
-; CHECK: @_ZZN9SingletonI1SE11getInstanceEvE13instance_weak = available_externally dso_local global %struct.S* null, align 8
-; CHECK: define linkonce_odr dso_local dereferenceable(16) %struct.S* @_ZN9SingletonI1SE11getInstanceEv() comdat
-; INTERNALIZE: define internal dereferenceable(16) %struct.S* @_ZN9SingletonI1SE11getInstanceEv()
+; CHECK: @_ZZN9SingletonI1SE11getInstanceEvE13instance_weak = available_externally dso_local global ptr null, align 8
+; CHECK: define linkonce_odr dso_local dereferenceable(16) ptr @_ZN9SingletonI1SE11getInstanceEv() comdat
+; INTERNALIZE: define internal dereferenceable(16) ptr @_ZN9SingletonI1SE11getInstanceEv()
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 %struct.S = type { i64, i64 }
 
 $_ZN9SingletonI1SE11getInstanceEv = comdat any
 

llvm/tools/gold/gold-plugin.cpp

#endif
   // Debug new pass manager
   static bool debug_pass_manager = false;
   // Directory to store the .dwo files.
   static std::string dwo_dir;
   /// Statistics output filename.
   static std::string stats_file;
   // Asserts that LTO link has whole program visibility
   static bool whole_program_visibility = false;
+  // Use opaque pointer types.
+  static bool opaque_pointers = true;
 
   // Optimization remarks filename, accepted passes and hotness options
   static std::string RemarksFilename;
   static std::string RemarksPasses;
   static bool RemarksWithHotness = false;
   static Optional<uint64_t> RemarksHotnessThreshold = 0;
   static std::string RemarksFormat;
 
if (opt.consume_front("mcpu=")) {
       if (!ResultOrErr)
         message(LDPL_FATAL, "Invalid remarks hotness threshold: %s", opt);
       else
         RemarksHotnessThreshold = *ResultOrErr;
     } else if (opt.consume_front("opt-remarks-format=")) {
       RemarksFormat = std::string(opt);
     } else if (opt.consume_front("stats-file=")) {
       stats_file = std::string(opt);
+    } else if (opt == "opaque-pointers") {
+      opaque_pointers = true;
+    } else if (opt == "no-opaque-pointers") {
+      opaque_pointers = false;
     } else {
       // Save this option to pass to the code generator.
       // ParseCommandLineOptions() expects argv[0] to be program name. Lazily
       // add that.
       if (extra.empty())
         extra.push_back("LLVMgold");
 
       extra.push_back(opt_);
static std::unique_ptr<LTO> createLTO(IndexWriteCallback OnIndexWrite,
   Conf.RemarksHotnessThreshold = options::RemarksHotnessThreshold;
   Conf.RemarksFormat = options::RemarksFormat;
 
   // Debug new pass manager if requested
   Conf.DebugPassManager = options::debug_pass_manager;
 
   Conf.HasWholeProgramVisibility = options::whole_program_visibility;
 
+  Conf.OpaquePointers = options.opaque_pointers;
+
   Conf.StatsFile = options::stats_file;
   return std::make_unique<LTO>(std::move(Conf), Backend,
                                 options::ParallelCodeGenParallelismLevel);
 }
 
 // Write empty files that may be expected by a distributed build
 // system when invoked with thinlto_index_only. This is invoked when
 // the linker has decided not to include the given module in the

llvm/tools/llvm-lto2/llvm-lto2.cpp

static cl::opt<std::string>
     CSPGOFile("lto-cspgo-profile-file",
               cl::desc("Specify a context sensitive PGO profile file"));
 
 static cl::opt<bool>
     RunCSIRInstr("lto-cspgo-gen",
                  cl::desc("Run PGO context sensitive IR instrumentation"),
                  cl::init(false), cl::Hidden);
 
+static cl::opt<bool> LtoOpaquePointers("lto-opaque-pointers",
+                                       cl::desc("Enable opaque pointer types"),
+                                       cl::init(true), cl::Hidden);
+
 static cl::opt<bool>
     DebugPassManager("debug-pass-manager", cl::init(false), cl::Hidden,
                      cl::desc("Print pass management debugging information"));
 
 static cl::opt<std::string>
     StatsFile("stats-file", cl::desc("Filename to write statistics to"));
 
 static cl::list<std::string>
static int run(int argc, char **argv) {
   if (auto FT = codegen::getExplicitFileType())
     Conf.CGFileType = FT.getValue();
 
   Conf.OverrideTriple = OverrideTriple;
   Conf.DefaultTriple = DefaultTriple;
   Conf.StatsFile = StatsFile;
   Conf.PTO.LoopVectorization = Conf.OptLevel > 1;
   Conf.PTO.SLPVectorization = Conf.OptLevel > 1;
+  Conf.OpaquePointers = LtoOpaquePointers;
 
   ThinBackend Backend;
   if (ThinLTODistributedIndexes)
     Backend = createWriteIndexesThinBackend(/* OldPrefix */ "",
                                             /* NewPrefix */ "",
                                             /* ShouldEmitImportsFiles */ true,
                                             /* LinkedObjectsFile */ nullptr,
                                             /* OnWrite */ {});