This is an archive of the discontinued LLVM Phabricator instance.

Differential D64931

Change X86 datalayout for three address spaces that specify pointer sizes.
ClosedPublic

Authored by akhuang on Jul 18 2019, 9:44 AM.

Details

Reviewers
rnk
craig.topper
RKSimon
reames
• espindola
Summary

This patch adds -p270:32:32-p271:32:32-p272:64:64 to the X86 data layout string, to be used for implementing mixed pointer sizes.

This will be used for an upcoming change that uses these three address spaces which will be used to implement the microsoft extensions ptr32, ptr64, sptr, and uptr. The address spaces specify whether a pointer is 32 bit sign extended, 32 bit zero extended, or 64 bit.

This patch also changes the datalayout string in tests that contain a datalayout string, because the datalayout specified in the llvm module has to match the target datalayout.

The numbers 270-272 are more or less arbitrary; I picked them because they're near 256-258, which are the current existing address spaces.

Diff Detail

Event Timeline

akhuang created this revision.Jul 18 2019, 9:44 AM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptJul 18 2019, 9:44 AM
Herald added subscribers: llvm-commits, cfe-commits, sanjoy and 6 others. · View Herald Transcript
Harbormaster completed remote builds in B35282: Diff 210607.Jul 18 2019, 9:47 AM
JohnReagan added a subscriber: JohnReagan.Jul 18 2019, 10:46 AM
rnk added reviewers: craig.topper, RKSimon.Jul 18 2019, 1:19 PM

I suggested to @akhuang offline that we should discuss this on llvm-dev. I'll add some other X86 reviewers.

akhuang added a comment.Aug 8 2019, 10:52 AM

The llvm-dev discussion is here http://lists.llvm.org/pipermail/llvm-dev/2019-July/134035.html
I think the consensus is that it should be fine to change the data layout.

lebedev.ri added a subscriber: lebedev.ri.Aug 8 2019, 11:00 AM

Why do you need to change (update) the datalayout in every single test?
That looks extremely noisy and hides the actually-needed changes.

lebedev.ri added inline comments.Aug 8 2019, 11:07 AM
clang/lib/Basic/Targets/OSTargets.h
778–780

I'd expect that this should be guarded by whatever flag is used for ms extensions.
Put differently, i i'm not sure that when those extensions are not enabled, the datalayout should be changed?

rnk added inline comments.Aug 8 2019, 11:35 AM
clang/lib/Basic/Targets/OSTargets.h
778–780

As discussed in the RFC, other people find these address spaces generally useful, and there is no need to limit them to just Windows or *-windows-msvc targets. Making it conditional would require mirroring the same conditional into LLVM, because LLVM and clang have to agree on data layout.

akhuang added a comment.Aug 8 2019, 11:53 AM

For some reason the tests were failing before without the datalayout change? I'm not sure why, but I changed them back and they're fine.

akhuang updated this revision to Diff 214202.Aug 8 2019, 11:53 AM

Remove test case changes.

Harbormaster completed remote builds in B36450: Diff 214202.Aug 8 2019, 11:54 AM
lebedev.ri added a reviewer: reames.Aug 8 2019, 11:55 AM
lebedev.ri added inline comments.
llvm/lib/Target/X86/X86TargetMachine.cpp
120–121

I may be wrong but this seems to not match what has been said in the responses to RFC.

akhuang added a comment.Aug 8 2019, 3:42 PM

@lebedev.ri The test case datalayout strings were changed because somewhere llvm asserts that the string in the IR matches the backend datalayout. I don't know why I wasn't getting the assert error now, but I think they'll all have to be changed if we change the X86 datalayout?

lebedev.ri added a comment.Aug 8 2019, 3:47 PM
In D64931#1622038, @akhuang wrote:

@lebedev.ri The test case datalayout strings were changed because somewhere llvm asserts that the string in the IR matches the backend datalayout. I don't know why I wasn't getting the assert error now, but I think they'll all have to be changed

Can you post a reproducer?

In D64931#1622038, @akhuang wrote:

if we change the X86 datalayout?

I think this is precisely what was discussed in replies to RFC - this hardcodes these address spaces,
and thus either makes them unavaliable for other front-ends and/or forces them to use them with Precisely Same Meaning.

akhuang added a comment.Aug 8 2019, 5:17 PM

Can you post a reproducer?

Turns out I just didn't have assertions enabled. With assertions the changed test cases should fail.

I think this is precisely what was discussed in replies to RFC - this hardcodes these address spaces, and thus either makes them unavaliable for other front-ends and/or forces them to use them with Precisely Same Meaning.

It seems like the RFC replies agreed that this should be implemented with address spaces, and that the information for these is encoded in the data layout. I think there was some confusion as to whether there would be more changes in addition to the data layout change?

lebedev.ri added a comment.Aug 9 2019, 5:29 AM
In D64931#1622144, @akhuang wrote:

Can you post a reproducer?

Turns out I just didn't have assertions enabled. With assertions the changed test cases should fail.

I think this is precisely what was discussed in replies to RFC - this hardcodes these address spaces, and thus either makes them unavaliable for other front-ends and/or forces them to use them with Precisely Same Meaning.

It seems like the RFC replies agreed that this should be implemented with address spaces, and that the information for these is encoded in the data layout.

Yes, *in front-end*.
llvm/lib/Target/X86/X86TargetMachine.cpp is *not* front-end, therefore

In D64931#1622039, @lebedev.ri wrote:

this hardcodes these address spaces, and thus either makes them unavaliable for other front-ends and/or forces them to use them with Precisely Same Meaning.

In D64931#1622144, @akhuang wrote:

I think there was some confusion as to whether there would be more changes in addition to the data layout change?

arsenm added a subscriber: arsenm.Aug 9 2019, 8:28 AM
In D64931#1622039, @lebedev.ri wrote:
In D64931#1622038, @akhuang wrote:

@lebedev.ri The test case datalayout strings were changed because somewhere llvm asserts that the string in the IR matches the backend datalayout. I don't know why I wasn't getting the assert error now, but I think they'll all have to be changed

Can you post a reproducer?

In D64931#1622038, @akhuang wrote:

if we change the X86 datalayout?

I think this is precisely what was discussed in replies to RFC - this hardcodes these address spaces,
and thus either makes them unavaliable for other front-ends and/or forces them to use them with Precisely Same Meaning.

Address space have backend defined semantics, and aren’t really reserved for front end use. I think the fact that non-0 address spaces on X86 codegen the same as address space 0 and could be used for something by a front end is an accident of how SelectionDAG is implemented. If X86 wants to reserve address space ranges for frontend use, that would need to be decided and documented. You don’t necessarily get the current behavior for free in GlobalISel since pointer types are distinct, so this would specifically need to be implemented.

akhuang updated this revision to Diff 215452.Aug 15 2019, 11:54 AM
  • Change the datalayout strings in test cases for x86 so they match the new datalayout and tests pass.
  • Change the address space numbers, mostly so I don't have to change the fact that currently address spaces under

256 don't do anything.

Herald added a subscriber: seiya. · View Herald TranscriptAug 15 2019, 11:54 AM
Harbormaster completed remote builds in B36849: Diff 215452.Aug 15 2019, 11:54 AM
akhuang edited the summary of this revision. (Show Details)Aug 15 2019, 11:54 AM
akhuang added a comment.Aug 16 2019, 1:44 PM

Address space have backend defined semantics, and aren’t really reserved for front end use. I think the fact that non-0 address spaces on X86 codegen the same as address space 0 and could be used for something by a front end is an accident of how SelectionDAG is implemented. If X86 wants to reserve address space ranges for frontend use, that would need to be decided and documented. You don’t necessarily get the current behavior for free in GlobalISel since pointer types are distinct, so this would specifically need to be implemented.

By this do you mean that this would be an instance of address spaces being used by the frontend? Or just that adding meaning to address spaces shouldn't be breaking other frontends?

arsenm added a comment.Aug 16 2019, 2:31 PM
In D64931#1633669, @akhuang wrote:

Address space have backend defined semantics, and aren’t really reserved for front end use. I think the fact that non-0 address spaces on X86 codegen the same as address space 0 and could be used for something by a front end is an accident of how SelectionDAG is implemented. If X86 wants to reserve address space ranges for frontend use, that would need to be decided and documented. You don’t necessarily get the current behavior for free in GlobalISel since pointer types are distinct, so this would specifically need to be implemented.

By this do you mean that this would be an instance of address spaces being used by the frontend? Or just that adding meaning to address spaces shouldn't be breaking other frontends?

I mean if frontends are relying on current specific behavior for these address spaces, that’s not something that’s documented to work. It just happens to

akhuang updated this revision to Diff 216894.Aug 23 2019, 10:26 AM
  • Change datalayout in lld test cases.
Herald added a reviewer: • espindola. · View Herald TranscriptAug 23 2019, 10:26 AM
Herald added subscribers: MaskRay, aheejin, arichardson and 2 others. · View Herald Transcript
Harbormaster completed remote builds in B37204: Diff 216894.Aug 23 2019, 10:26 AM
akhuang edited the summary of this revision. (Show Details)Aug 26 2019, 4:00 PM
rnk accepted this revision.Aug 26 2019, 4:07 PM

I think we're ready to proceed here, lgtm. Shout if I've misrepresented anything. :)

This revision is now accepted and ready to land.Aug 26 2019, 4:07 PM
akhuang added a comment.Aug 26 2019, 4:10 PM

Pinging reviewers -- are there any other concerns on this patch?

akhuang updated this revision to Diff 217263.Aug 26 2019, 4:25 PM

Rebase

Harbormaster completed remote builds in B37317: Diff 217263.Aug 26 2019, 4:25 PM
akhuang closed this revision.Aug 27 2019, 10:59 AM

Commited in r370083

dyung added a subscriber: dyung.Aug 27 2019, 2:57 PM

Hi, this is causing 3 test failures on the PS4 linux bot. The changes may not have been initially flagged because a different issue was causing a build failure which masked the problem. I have bisected the test failures to this change though.

http://lab.llvm.org:8011/builders/llvm-clang-lld-x86_64-scei-ps4-ubuntu-fast/builds/53916

LLVM :: LTO/Resolution/X86/not-prevailing-weak-aliasee.ll
LLVM :: ThinLTO/X86/printer.ll
lld :: ELF/lto/drop-debug-info.ll

Can you take a look?

dyung added a comment.Aug 27 2019, 3:07 PM
In D64931#1647880, @dyung wrote:

Hi, this is causing 3 test failures on the PS4 linux bot. The changes may not have been initially flagged because a different issue was causing a build failure which masked the problem. I have bisected the test failures to this change though.

http://lab.llvm.org:8011/builders/llvm-clang-lld-x86_64-scei-ps4-ubuntu-fast/builds/53916

LLVM :: LTO/Resolution/X86/not-prevailing-weak-aliasee.ll
LLVM :: ThinLTO/X86/printer.ll
lld :: ELF/lto/drop-debug-info.ll

Actually it appears the llvm tests were fixed up in r370105 leaving only the LLD test failing.

Can you take a look?

Revision Contents

PathSize
clang/
lib/
Basic/
Targets/
6 lines
32 lines
test/
CodeGen/
Inputs/
2 lines
2 lines
2 lines
2 lines
3 lines
14 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
lld/
test/
COFF/
Inputs/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
ELF/
lto/
Inputs/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
wasm/
lto/
2 lines
llvm/
lib/
Target/
X86/
3 lines
test/
LTO/
Resolution/
X86/
Inputs/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
X86/
Inputs/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
ThinLTO/
X86/
Inputs/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Transforms/
FunctionImport/
Inputs/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
PGOProfile/
Inputs/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
X86/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
tools/
llvm-lto2/
X86/
2 lines
2 lines

Diff 217263

clang/lib/Basic/Targets/OSTargets.h

Show First 20 Lines • Show All 769 Lines • ▼ Show 20 Lines NaClTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
this->SizeType = TargetInfo::UnsignedInt; this->SizeType = TargetInfo::UnsignedInt;
this->PtrDiffType = TargetInfo::SignedInt; this->PtrDiffType = TargetInfo::SignedInt;
this->IntPtrType = TargetInfo::SignedInt; this->IntPtrType = TargetInfo::SignedInt;
// RegParmMax is inherited from the underlying architecture. // RegParmMax is inherited from the underlying architecture.
this->LongDoubleFormat = &llvm::APFloat::IEEEdouble(); this->LongDoubleFormat = &llvm::APFloat::IEEEdouble();
if (Triple.getArch() == llvm::Triple::arm) { if (Triple.getArch() == llvm::Triple::arm) {
// Handled in ARM's setABI(). // Handled in ARM's setABI().
} else if (Triple.getArch() == llvm::Triple::x86) { } else if (Triple.getArch() == llvm::Triple::x86) {
this->resetDataLayout("e-m:e-p:32:32-i64:64-n8:16:32-S128"); this->resetDataLayout("e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-"
"i64:64-n8:16:32-S128");
} else if (Triple.getArch() == llvm::Triple::x86_64) { } else if (Triple.getArch() == llvm::Triple::x86_64) {
lebedev.riUnsubmitted
Not Done
ReplyInline Actions

I'd expect that this should be guarded by whatever flag is used for ms extensions.
Put differently, i i'm not sure that when those extensions are not enabled, the datalayout should be changed?

lebedev.ri: I'd expect that this should be guarded by whatever flag is used for ms extensions. Put…
rnkUnsubmitted
Not Done
ReplyInline Actions

As discussed in the RFC, other people find these address spaces generally useful, and there is no need to limit them to just Windows or *-windows-msvc targets. Making it conditional would require mirroring the same conditional into LLVM, because LLVM and clang have to agree on data layout.

rnk: As discussed in the RFC, other people find these address spaces generally useful, and there is…
this->resetDataLayout("e-m:e-p:32:32-i64:64-n8:16:32:64-S128"); this->resetDataLayout("e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-"
"i64:64-n8:16:32:64-S128");
} else if (Triple.getArch() == llvm::Triple::mipsel) { } else if (Triple.getArch() == llvm::Triple::mipsel) {
// Handled on mips' setDataLayout. // Handled on mips' setDataLayout.
} else { } else {
assert(Triple.getArch() == llvm::Triple::le32); assert(Triple.getArch() == llvm::Triple::le32);
this->resetDataLayout("e-p:32:32-i64:64"); this->resetDataLayout("e-p:32:32-i64:64");
} }
} }
}; };
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

clang/lib/Basic/Targets/X86.h

Show First 20 Lines • Show All 334 Lines • ▼ Show 20 Lines
class LLVM_LIBRARY_VISIBILITY X86_32TargetInfo : public X86TargetInfo { class LLVM_LIBRARY_VISIBILITY X86_32TargetInfo : public X86TargetInfo {
public: public:
X86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) X86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
: X86TargetInfo(Triple, Opts) { : X86TargetInfo(Triple, Opts) {
DoubleAlign = LongLongAlign = 32; DoubleAlign = LongLongAlign = 32;
LongDoubleWidth = 96; LongDoubleWidth = 96;
LongDoubleAlign = 32; LongDoubleAlign = 32;
SuitableAlign = 128; SuitableAlign = 128;
resetDataLayout("e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128"); resetDataLayout("e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-"
"f80:32-n8:16:32-S128");
SizeType = UnsignedInt; SizeType = UnsignedInt;
PtrDiffType = SignedInt; PtrDiffType = SignedInt;
IntPtrType = SignedInt; IntPtrType = SignedInt;
RegParmMax = 3; RegParmMax = 3;
// Use fpret for all types. // Use fpret for all types.
RealTypeUsesObjCFPRet = RealTypeUsesObjCFPRet =
((1 << TargetInfo::Float) | (1 << TargetInfo::Double) | ((1 << TargetInfo::Float) | (1 << TargetInfo::Double) |
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines DarwinI386TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
SuitableAlign = 128; SuitableAlign = 128;
MaxVectorAlign = 256; MaxVectorAlign = 256;
// The watchOS simulator uses the builtin bool type for Objective-C. // The watchOS simulator uses the builtin bool type for Objective-C.
llvm::Triple T = llvm::Triple(Triple); llvm::Triple T = llvm::Triple(Triple);
if (T.isWatchOS()) if (T.isWatchOS())
UseSignedCharForObjCBool = false; UseSignedCharForObjCBool = false;
SizeType = UnsignedLong; SizeType = UnsignedLong;
IntPtrType = SignedLong; IntPtrType = SignedLong;
resetDataLayout("e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128"); resetDataLayout("e-m:o-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-"
"f80:128-n8:16:32-S128");
HasAlignMac68kSupport = true; HasAlignMac68kSupport = true;
} }
bool handleTargetFeatures(std::vector<std::string> &Features, bool handleTargetFeatures(std::vector<std::string> &Features,
DiagnosticsEngine &Diags) override { DiagnosticsEngine &Diags) override {
if (!DarwinTargetInfo<X86_32TargetInfo>::handleTargetFeatures(Features, if (!DarwinTargetInfo<X86_32TargetInfo>::handleTargetFeatures(Features,
Diags)) Diags))
return false; return false;
// We now know the features we have: we can decide how to align vectors. // We now know the features we have: we can decide how to align vectors.
MaxVectorAlign = MaxVectorAlign =
hasFeature("avx512f") ? 512 : hasFeature("avx") ? 256 : 128; hasFeature("avx512f") ? 512 : hasFeature("avx") ? 256 : 128;
return true; return true;
} }
}; };
// x86-32 Windows target // x86-32 Windows target
class LLVM_LIBRARY_VISIBILITY WindowsX86_32TargetInfo class LLVM_LIBRARY_VISIBILITY WindowsX86_32TargetInfo
: public WindowsTargetInfo<X86_32TargetInfo> { : public WindowsTargetInfo<X86_32TargetInfo> {
public: public:
WindowsX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) WindowsX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
: WindowsTargetInfo<X86_32TargetInfo>(Triple, Opts) { : WindowsTargetInfo<X86_32TargetInfo>(Triple, Opts) {
DoubleAlign = LongLongAlign = 64; DoubleAlign = LongLongAlign = 64;
bool IsWinCOFF = bool IsWinCOFF =
getTriple().isOSWindows() && getTriple().isOSBinFormatCOFF(); getTriple().isOSWindows() && getTriple().isOSBinFormatCOFF();
resetDataLayout(IsWinCOFF resetDataLayout(IsWinCOFF ? "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:"
? "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" "64-i64:64-f80:32-n8:16:32-a:0:32-S32"
: "e-m:e-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"); : "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:"
"64-i64:64-f80:32-n8:16:32-a:0:32-S32");
} }
}; };
// x86-32 Windows Visual Studio target // x86-32 Windows Visual Studio target
class LLVM_LIBRARY_VISIBILITY MicrosoftX86_32TargetInfo class LLVM_LIBRARY_VISIBILITY MicrosoftX86_32TargetInfo
: public WindowsX86_32TargetInfo { : public WindowsX86_32TargetInfo {
public: public:
MicrosoftX86_32TargetInfo(const llvm::Triple &Triple, MicrosoftX86_32TargetInfo(const llvm::Triple &Triple,
Show All 31 Lines
// x86-32 Cygwin target // x86-32 Cygwin target
class LLVM_LIBRARY_VISIBILITY CygwinX86_32TargetInfo : public X86_32TargetInfo { class LLVM_LIBRARY_VISIBILITY CygwinX86_32TargetInfo : public X86_32TargetInfo {
public: public:
CygwinX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) CygwinX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
: X86_32TargetInfo(Triple, Opts) { : X86_32TargetInfo(Triple, Opts) {
this->WCharType = TargetInfo::UnsignedShort; this->WCharType = TargetInfo::UnsignedShort;
DoubleAlign = LongLongAlign = 64; DoubleAlign = LongLongAlign = 64;
resetDataLayout("e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"); resetDataLayout("e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:"
"32-n8:16:32-a:0:32-S32");
} }
void getTargetDefines(const LangOptions &Opts, void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override { MacroBuilder &Builder) const override {
X86_32TargetInfo::getTargetDefines(Opts, Builder); X86_32TargetInfo::getTargetDefines(Opts, Builder);
Builder.defineMacro("_X86_"); Builder.defineMacro("_X86_");
Builder.defineMacro("__CYGWIN__"); Builder.defineMacro("__CYGWIN__");
Builder.defineMacro("__CYGWIN32__"); Builder.defineMacro("__CYGWIN32__");
Show All 20 Lines
// X86-32 MCU target // X86-32 MCU target
class LLVM_LIBRARY_VISIBILITY MCUX86_32TargetInfo : public X86_32TargetInfo { class LLVM_LIBRARY_VISIBILITY MCUX86_32TargetInfo : public X86_32TargetInfo {
public: public:
MCUX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) MCUX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
: X86_32TargetInfo(Triple, Opts) { : X86_32TargetInfo(Triple, Opts) {
LongDoubleWidth = 64; LongDoubleWidth = 64;
LongDoubleFormat = &llvm::APFloat::IEEEdouble(); LongDoubleFormat = &llvm::APFloat::IEEEdouble();
resetDataLayout("e-m:e-p:32:32-i64:32-f64:32-f128:32-n8:16:32-a:0:32-S32"); resetDataLayout("e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:32-f64:"
"32-f128:32-n8:16:32-a:0:32-S32");
WIntType = UnsignedInt; WIntType = UnsignedInt;
} }
CallingConvCheckResult checkCallingConvention(CallingConv CC) const override { CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
// On MCU we support only C calling convention. // On MCU we support only C calling convention.
return CC == CC_C ? CCCR_OK : CCCR_Warning; return CC == CC_C ? CCCR_OK : CCCR_Warning;
} }
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines X86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
SizeType = IsX32 ? UnsignedInt : UnsignedLong; SizeType = IsX32 ? UnsignedInt : UnsignedLong;
PtrDiffType = IsX32 ? SignedInt : SignedLong; PtrDiffType = IsX32 ? SignedInt : SignedLong;
IntPtrType = IsX32 ? SignedInt : SignedLong; IntPtrType = IsX32 ? SignedInt : SignedLong;
IntMaxType = IsX32 ? SignedLongLong : SignedLong; IntMaxType = IsX32 ? SignedLongLong : SignedLong;
Int64Type = IsX32 ? SignedLongLong : SignedLong; Int64Type = IsX32 ? SignedLongLong : SignedLong;
RegParmMax = 6; RegParmMax = 6;
// Pointers are 32-bit in x32. // Pointers are 32-bit in x32.
resetDataLayout(IsX32 resetDataLayout(IsX32 ? "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-"
? "e-m:e-p:32:32-i64:64-f80:128-n8:16:32:64-S128" "i64:64-f80:128-n8:16:32:64-S128"
: IsWinCOFF ? "e-m:w-i64:64-f80:128-n8:16:32:64-S128" : IsWinCOFF ? "e-m:w-p270:32:32-p271:32:32-p272:64:"
: "e-m:e-i64:64-f80:128-n8:16:32:64-S128"); "64-i64:64-f80:128-n8:16:32:64-S128"
: "e-m:e-p270:32:32-p271:32:32-p272:64:"
"64-i64:64-f80:128-n8:16:32:64-S128");
// Use fpret only for long double. // Use fpret only for long double.
RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble); RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
// Use fp2ret for _Complex long double. // Use fp2ret for _Complex long double.
ComplexLongDoubleUsesFP2Ret = true; ComplexLongDoubleUsesFP2Ret = true;
// Make __builtin_ms_va_list available. // Make __builtin_ms_va_list available.
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Lines
public: public:
DarwinX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) DarwinX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
: DarwinTargetInfo<X86_64TargetInfo>(Triple, Opts) { : DarwinTargetInfo<X86_64TargetInfo>(Triple, Opts) {
Int64Type = SignedLongLong; Int64Type = SignedLongLong;
// The 64-bit iOS simulator uses the builtin bool type for Objective-C. // The 64-bit iOS simulator uses the builtin bool type for Objective-C.
llvm::Triple T = llvm::Triple(Triple); llvm::Triple T = llvm::Triple(Triple);
if (T.isiOS()) if (T.isiOS())
UseSignedCharForObjCBool = false; UseSignedCharForObjCBool = false;
resetDataLayout("e-m:o-i64:64-f80:128-n8:16:32:64-S128"); resetDataLayout("e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:"
"16:32:64-S128");
} }
bool handleTargetFeatures(std::vector<std::string> &Features, bool handleTargetFeatures(std::vector<std::string> &Features,
DiagnosticsEngine &Diags) override { DiagnosticsEngine &Diags) override {
if (!DarwinTargetInfo<X86_64TargetInfo>::handleTargetFeatures(Features, if (!DarwinTargetInfo<X86_64TargetInfo>::handleTargetFeatures(Features,
Diags)) Diags))
return false; return false;
// We now know the features we have: we can decide how to align vectors. // We now know the features we have: we can decide how to align vectors.
Show All 40 Lines

clang/test/CodeGen/Inputs/thinlto-multi-module.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @f2() { define void @f2() {
ret void ret void
} }
!0 = !{i32 1, !"ThinLTO", i32 0} !0 = !{i32 1, !"ThinLTO", i32 0}
!llvm.module.flags = !{ !0 } !llvm.module.flags = !{ !0 }

clang/test/CodeGen/Inputs/thinlto_backend.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @f2() { define void @f2() {
ret void ret void
} }

clang/test/CodeGen/Inputs/thinlto_backend_local_name_conflict1.ll

; ModuleID = 'local_name_conflict_var.o' ; ModuleID = 'local_name_conflict_var.o'
source_filename = "local_name_conflict_var.c" source_filename = "local_name_conflict_var.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@baz = internal global i32 10, align 4 @baz = internal global i32 10, align 4
; Function Attrs: noinline nounwind uwtable ; Function Attrs: noinline nounwind uwtable
define i32 @a() { define i32 @a() {
entry: entry:
%0 = load i32, i32* @baz, align 4 %0 = load i32, i32* @baz, align 4
ret i32 %0 ret i32 %0
} }

clang/test/CodeGen/Inputs/thinlto_backend_local_name_conflict2.ll

; ModuleID = 'local_name_conflict_var.o' ; ModuleID = 'local_name_conflict_var.o'
source_filename = "local_name_conflict_var.c" source_filename = "local_name_conflict_var.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@baz = internal global i32 10, align 4 @baz = internal global i32 10, align 4
; Function Attrs: noinline nounwind uwtable ; Function Attrs: noinline nounwind uwtable
define i32 @b() { define i32 @b() {
entry: entry:
%0 = load i32, i32* @baz, align 4 %0 = load i32, i32* @baz, align 4
ret i32 %0 ret i32 %0
} }

clang/test/CodeGen/iamcu-abi.c

// RUN: %clang_cc1 -triple i386-pc-elfiamcu -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -triple i386-pc-elfiamcu -emit-llvm -o - %s | FileCheck %s
// CHECK: target datalayout = "e-m:e-p:32:32-i64:32-f64:32-f128:32-n8:16:32-a:0:32-S32" // CHECK: target datalayout = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:32-f64:32-f128:32-n8:16:32-a:0:32-S32"
// CHECK: target triple = "i386-pc-elfiamcu" // CHECK: target triple = "i386-pc-elfiamcu"
void food(double *d); void food(double *d);
void fooll(long long *ll); void fooll(long long *ll);
void fooull(unsigned long long *ull); void fooull(unsigned long long *ull);
void foold(long double *ld); void foold(long double *ld);
// CHECK-LABEL: define void @testdouble() // CHECK-LABEL: define void @testdouble()
// CHECK: alloca double, align 4 // CHECK: alloca double, align 4
void testdouble() { void testdouble() {
Show All 24 Lines

clang/test/CodeGen/target-data.c

// RUN: %clang_cc1 -triple i686-unknown-unknown -emit-llvm -o - %s | \ // RUN: %clang_cc1 -triple i686-unknown-unknown -emit-llvm -o - %s | \
// RUN: FileCheck --check-prefix=I686-UNKNOWN %s // RUN: FileCheck --check-prefix=I686-UNKNOWN %s
// I686-UNKNOWN: target datalayout = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128" // I686-UNKNOWN: target datalayout = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128"
// RUN: %clang_cc1 -triple i686-apple-darwin9 -emit-llvm -o - %s | \ // RUN: %clang_cc1 -triple i686-apple-darwin9 -emit-llvm -o - %s | \
// RUN: FileCheck --check-prefix=I686-DARWIN %s // RUN: FileCheck --check-prefix=I686-DARWIN %s
// I686-DARWIN: target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128" // I686-DARWIN: target datalayout = "e-m:o-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:128-n8:16:32-S128"
// RUN: %clang_cc1 -triple i686-unknown-win32 -emit-llvm -o - %s | \ // RUN: %clang_cc1 -triple i686-unknown-win32 -emit-llvm -o - %s | \
// RUN: FileCheck --check-prefix=I686-WIN32 %s // RUN: FileCheck --check-prefix=I686-WIN32 %s
// I686-WIN32: target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" // I686-WIN32: target datalayout = "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:32-n8:16:32-a:0:32-S32"
// RUN: %clang_cc1 -triple i686-unknown-cygwin -emit-llvm -o - %s | \ // RUN: %clang_cc1 -triple i686-unknown-cygwin -emit-llvm -o - %s | \
// RUN: FileCheck --check-prefix=I686-CYGWIN %s // RUN: FileCheck --check-prefix=I686-CYGWIN %s
// I686-CYGWIN: target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" // I686-CYGWIN: target datalayout = "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:32-n8:16:32-a:0:32-S32"
// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s | \ // RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s | \
// RUN: FileCheck --check-prefix=X86_64 %s // RUN: FileCheck --check-prefix=X86_64 %s
// X86_64: target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" // X86_64: target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
// RUN: %clang_cc1 -triple xcore-unknown-unknown -emit-llvm -o - %s | \ // RUN: %clang_cc1 -triple xcore-unknown-unknown -emit-llvm -o - %s | \
// RUN: FileCheck --check-prefix=XCORE %s // RUN: FileCheck --check-prefix=XCORE %s
// XCORE: target datalayout = "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32-f64:32-a:0:32-n32" // XCORE: target datalayout = "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32-f64:32-a:0:32-n32"
// RUN: %clang_cc1 -triple sparc-sun-solaris -emit-llvm -o - %s | \ // RUN: %clang_cc1 -triple sparc-sun-solaris -emit-llvm -o - %s | \
// RUN: FileCheck %s --check-prefix=SPARC-V8 // RUN: FileCheck %s --check-prefix=SPARC-V8
// SPARC-V8: target datalayout = "E-m:e-p:32:32-i64:64-f128:64-n32-S64" // SPARC-V8: target datalayout = "E-m:e-p:32:32-i64:64-f128:64-n32-S64"
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
// MIPS-64EB-N32: target datalayout = "E-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128" // MIPS-64EB-N32: target datalayout = "E-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128"
// RUN: %clang_cc1 -triple powerpc64-lv2 -o - -emit-llvm %s | \ // RUN: %clang_cc1 -triple powerpc64-lv2 -o - -emit-llvm %s | \
// RUN: FileCheck %s -check-prefix=PS3 // RUN: FileCheck %s -check-prefix=PS3
// PS3: target datalayout = "E-m:e-p:32:32-i64:64-n32:64" // PS3: target datalayout = "E-m:e-p:32:32-i64:64-n32:64"
// RUN: %clang_cc1 -triple i686-nacl -o - -emit-llvm %s | \ // RUN: %clang_cc1 -triple i686-nacl -o - -emit-llvm %s | \
// RUN: FileCheck %s -check-prefix=I686-NACL // RUN: FileCheck %s -check-prefix=I686-NACL
// I686-NACL: target datalayout = "e-m:e-p:32:32-i64:64-n8:16:32-S128" // I686-NACL: target datalayout = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-n8:16:32-S128"
// RUN: %clang_cc1 -triple x86_64-nacl -o - -emit-llvm %s | \ // RUN: %clang_cc1 -triple x86_64-nacl -o - -emit-llvm %s | \
// RUN: FileCheck %s -check-prefix=X86_64-NACL // RUN: FileCheck %s -check-prefix=X86_64-NACL
// X86_64-NACL: target datalayout = "e-m:e-p:32:32-i64:64-n8:16:32:64-S128" // X86_64-NACL: target datalayout = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-n8:16:32:64-S128"
// RUN: %clang_cc1 -triple arm-nacl -o - -emit-llvm %s | \ // RUN: %clang_cc1 -triple arm-nacl -o - -emit-llvm %s | \
// RUN: FileCheck %s -check-prefix=ARM-NACL // RUN: FileCheck %s -check-prefix=ARM-NACL
// ARM-NACL: target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S128" // ARM-NACL: target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S128"
// RUN: %clang_cc1 -triple mipsel-nacl -o - -emit-llvm %s | \ // RUN: %clang_cc1 -triple mipsel-nacl -o - -emit-llvm %s | \
// RUN: FileCheck %s -check-prefix=MIPS-NACL // RUN: FileCheck %s -check-prefix=MIPS-NACL
// MIPS-NACL: target datalayout = "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64" // MIPS-NACL: target datalayout = "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64"
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

clang/test/CodeGen/thinlto-diagnostic-handler-remarks-with-hotness.ll

Show All 26 Lines
; YAML-NEXT: - String: ')' ; YAML-NEXT: - String: ')'
; YAML-NEXT: ... ; YAML-NEXT: ...
; Next try with pass remarks to stderr ; Next try with pass remarks to stderr
; RUN: %clang -target x86_64-scei-ps4 -O2 -x ir %t.o -fthinlto-index=%t.thinlto.bc -mllvm -pass-remarks=inline -fdiagnostics-show-hotness -o %t2.o -c 2>&1 | FileCheck %s ; RUN: %clang -target x86_64-scei-ps4 -O2 -x ir %t.o -fthinlto-index=%t.thinlto.bc -mllvm -pass-remarks=inline -fdiagnostics-show-hotness -o %t2.o -c 2>&1 | FileCheck %s
; CHECK: tinkywinky inlined into main with (cost=0, threshold=337) (hotness: 300) ; CHECK: tinkywinky inlined into main with (cost=0, threshold=337) (hotness: 300)
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-scei-ps4" target triple = "x86_64-scei-ps4"
declare i32 @patatino() declare i32 @patatino()
define i32 @tinkywinky() { define i32 @tinkywinky() {
%a = call i32 @patatino() %a = call i32 @patatino()
ret i32 %a ret i32 %a
} }
define i32 @main() !prof !0 { define i32 @main() !prof !0 {
%i = call i32 @tinkywinky() %i = call i32 @tinkywinky()
ret i32 %i ret i32 %i
} }
!0 = !{!"function_entry_count", i64 300} !0 = !{!"function_entry_count", i64 300}

clang/test/CodeGen/thinlto-distributed-backend-skip.ll

; REQUIRES: x86-registered-target ; REQUIRES: x86-registered-target
; Check that ThinLTO backend respects "SkipModuleByDistributedBackend" ; Check that ThinLTO backend respects "SkipModuleByDistributedBackend"
; flag which can be set by indexing. ; flag which can be set by indexing.
; RUN: opt -thinlto-bc -o %t.o %s ; RUN: opt -thinlto-bc -o %t.o %s
; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu \ ; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu \
; RUN: -fthinlto-index=%S/Inputs/thinlto-distributed-backend-skip.bc \ ; RUN: -fthinlto-index=%S/Inputs/thinlto-distributed-backend-skip.bc \
; RUN: -emit-llvm -o - -x ir %t.o | FileCheck %s ; RUN: -emit-llvm -o - -x ir %t.o | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
; CHECK: "empty" ; CHECK: "empty"
; CHECK: target triple = ; CHECK: target triple =
; CHECK-NOT: @main ; CHECK-NOT: @main
define i32 @main() { define i32 @main() {
entry: entry:
ret i32 0 ret i32 0
} }

clang/test/CodeGen/thinlto-distributed-cfi-devirt.ll

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
; RUN: -emit-obj -fthinlto-index=%t.o.thinlto.bc -O2 \ ; RUN: -emit-obj -fthinlto-index=%t.o.thinlto.bc -O2 \
; RUN: -emit-llvm -o - -x ir %t.o | FileCheck %s --check-prefixes=CHECK-IR ; RUN: -emit-llvm -o - -x ir %t.o | FileCheck %s --check-prefixes=CHECK-IR
; Check that backend does not fail generating native code. ; Check that backend does not fail generating native code.
; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu \ ; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu \
; RUN: -emit-obj -fthinlto-index=%t.o.thinlto.bc -O2 \ ; RUN: -emit-obj -fthinlto-index=%t.o.thinlto.bc -O2 \
; RUN: -o %t.native.o -x ir %t.o ; RUN: -o %t.native.o -x ir %t.o
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
%struct.A = type { i32 (...)** } %struct.A = type { i32 (...)** }
%struct.B = type { %struct.A } %struct.B = type { %struct.A }
%struct.C = type { %struct.A } %struct.C = type { %struct.A }
@_ZTV1B = constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* undef, i8* bitcast (i32 (%struct.B*, i32)* @_ZN1B1fEi to i8*), i8* bitcast (i32 (%struct.A*, i32)* @_ZN1A1nEi to i8*)] }, !type !0, !type !1 @_ZTV1B = constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* undef, i8* bitcast (i32 (%struct.B*, i32)* @_ZN1B1fEi to i8*), i8* bitcast (i32 (%struct.A*, i32)* @_ZN1A1nEi to i8*)] }, !type !0, !type !1
@_ZTV1C = constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* undef, i8* bitcast (i32 (%struct.C*, i32)* @_ZN1C1fEi to i8*), i8* bitcast (i32 (%struct.A*, i32)* @_ZN1A1nEi to i8*)] }, !type !0, !type !2 @_ZTV1C = constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* undef, i8* bitcast (i32 (%struct.C*, i32)* @_ZN1C1fEi to i8*), i8* bitcast (i32 (%struct.A*, i32)* @_ZN1A1nEi to i8*)] }, !type !0, !type !2
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

clang/test/CodeGen/thinlto-distributed-cfi.ll

Show All 30 Lines
; RUN: -emit-obj -fthinlto-index=%t.o.thinlto.bc \ ; RUN: -emit-obj -fthinlto-index=%t.o.thinlto.bc \
; RUN: -emit-llvm -o - -x ir %t.o | FileCheck %s --check-prefixes=CHECK-IR ; RUN: -emit-llvm -o - -x ir %t.o | FileCheck %s --check-prefixes=CHECK-IR
; Ensure that backend does not fail generating native code. ; Ensure that backend does not fail generating native code.
; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu \ ; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu \
; RUN: -emit-obj -fthinlto-index=%t.o.thinlto.bc \ ; RUN: -emit-obj -fthinlto-index=%t.o.thinlto.bc \
; RUN: -o %t.native.o -x ir %t.o ; RUN: -o %t.native.o -x ir %t.o
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
%struct.B = type { %struct.A } %struct.B = type { %struct.A }
%struct.A = type { i32 (...)** } %struct.A = type { i32 (...)** }
@_ZTV1B = constant { [3 x i8*] } { [3 x i8*] [i8* undef, i8* undef, i8* undef] }, !type !0 @_ZTV1B = constant { [3 x i8*] } { [3 x i8*] [i8* undef, i8* undef, i8* undef] }, !type !0
; CHECK-IR-LABEL: define void @test ; CHECK-IR-LABEL: define void @test
Show All 27 Lines

clang/test/CodeGen/thinlto-distributed.ll

; REQUIRES: x86-registered-target ; REQUIRES: x86-registered-target
; Trivial test for distributes ThinLTO ; Trivial test for distributes ThinLTO
; RUN: opt -thinlto-bc -o %t.o %s ; RUN: opt -thinlto-bc -o %t.o %s
; RUN: llvm-lto2 run -thinlto-distributed-indexes %t.o \ ; RUN: llvm-lto2 run -thinlto-distributed-indexes %t.o \
; RUN: -o %t2.index \ ; RUN: -o %t2.index \
; RUN: -r=%t.o,main,px ; RUN: -r=%t.o,main,px
; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu \ ; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu \
; RUN: -emit-obj -fthinlto-index=%t.o.thinlto.bc \ ; RUN: -emit-obj -fthinlto-index=%t.o.thinlto.bc \
; RUN: -o %t.native.o -x ir %t.o ; RUN: -o %t.native.o -x ir %t.o
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
define i32 @main() { define i32 @main() {
entry: entry:
ret i32 0 ret i32 0
} }

clang/test/CodeGen/thinlto-multi-module.ll

; REQUIRES: x86-registered-target ; REQUIRES: x86-registered-target
; RUN: opt -module-summary -o %t1.o %s ; RUN: opt -module-summary -o %t1.o %s
; RUN: llvm-lto -thinlto -o %t %t1.o ; RUN: llvm-lto -thinlto -o %t %t1.o
; RUN: opt -module-summary -o %t2.o %S/Inputs/thinlto-multi-module.ll ; RUN: opt -module-summary -o %t2.o %S/Inputs/thinlto-multi-module.ll
; RUN: llvm-cat -b -o %t1cat.o %t2.o %t1.o ; RUN: llvm-cat -b -o %t1cat.o %t2.o %t1.o
; RUN: cp %t1cat.o %t1.o ; RUN: cp %t1cat.o %t1.o
; RUN: %clang -target x86_64-unknown-linux-gnu -O2 -o %t3.o -x ir %t1.o -c -fthinlto-index=%t.thinlto.bc ; RUN: %clang -target x86_64-unknown-linux-gnu -O2 -o %t3.o -x ir %t1.o -c -fthinlto-index=%t.thinlto.bc
; RUN: llvm-nm %t3.o | FileCheck --check-prefix=CHECK-OBJ %s ; RUN: llvm-nm %t3.o | FileCheck --check-prefix=CHECK-OBJ %s
; CHECK-OBJ: T f1 ; CHECK-OBJ: T f1
; CHECK-OBJ: U f2 ; CHECK-OBJ: U f2
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @f2() declare void @f2()
define void @f1() { define void @f1() {
call void @f2() call void @f2()
ret void ret void
} }

clang/test/CodeGen/thinlto_backend.ll

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
; CHECK-OBJ: T f1 ; CHECK-OBJ: T f1
; CHECK-OBJ-NOT: U f2 ; CHECK-OBJ-NOT: U f2
; Ensure we get expected error for input files without summaries ; Ensure we get expected error for input files without summaries
; RUN: opt -o %t2.o %s ; RUN: opt -o %t2.o %s
; RUN: %clang -target x86_64-unknown-linux-gnu -O2 -o %t3.o -x ir %t1.o -c -fthinlto-index=%t.thinlto.bc 2>&1 | FileCheck %s -check-prefix=CHECK-ERROR2 ; RUN: %clang -target x86_64-unknown-linux-gnu -O2 -o %t3.o -x ir %t1.o -c -fthinlto-index=%t.thinlto.bc 2>&1 | FileCheck %s -check-prefix=CHECK-ERROR2
; CHECK-ERROR2: Error loading imported file '{{.*}}': Could not find module summary ; CHECK-ERROR2: Error loading imported file '{{.*}}': Could not find module summary
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @f2() declare void @f2()
declare i8* @f3() declare i8* @f3()
define void @f1() { define void @f1() {
call void @f2() call void @f2()
; Make sure that the backend can handle undefined references. ; Make sure that the backend can handle undefined references.
; Do an indirect call so that the undefined ref shows up in the combined index. ; Do an indirect call so that the undefined ref shows up in the combined index.
call void bitcast (i8*()* @f3 to void()*)() call void bitcast (i8*()* @f3 to void()*)()
ret void ret void
} }

clang/test/CodeGen/thinlto_backend_local_name_conflict.ll

Show All 15 Lines
; imported as local copies. ; imported as local copies.
; RUN: %clang -target x86_64-unknown-linux-gnu -O2 -o %t4.o -x ir %t.bc -c -fthinlto-index=%t.bc.thinlto.bc -save-temps=obj ; RUN: %clang -target x86_64-unknown-linux-gnu -O2 -o %t4.o -x ir %t.bc -c -fthinlto-index=%t.bc.thinlto.bc -save-temps=obj
; RUN: llvm-dis %t.s.3.import.bc -o - | FileCheck --check-prefix=IMPORT %s ; RUN: llvm-dis %t.s.3.import.bc -o - | FileCheck --check-prefix=IMPORT %s
; IMPORT: @baz.llvm.{{.*}} = internal global i32 10 ; IMPORT: @baz.llvm.{{.*}} = internal global i32 10
; IMPORT: @baz.llvm.{{.*}} = internal global i32 10 ; IMPORT: @baz.llvm.{{.*}} = internal global i32 10
; ModuleID = 'local_name_conflict_var_main.o' ; ModuleID = 'local_name_conflict_var_main.o'
source_filename = "local_name_conflict_var_main.c" source_filename = "local_name_conflict_var_main.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: noinline nounwind uwtable ; Function Attrs: noinline nounwind uwtable
define i32 @main() { define i32 @main() {
entry: entry:
%call1 = call i32 (...) @a() %call1 = call i32 (...) @a()
%call2 = call i32 (...) @b() %call2 = call i32 (...) @b()
ret i32 0 ret i32 0
} }
declare i32 @a(...) declare i32 @a(...)
declare i32 @b(...) declare i32 @b(...)

lld/test/COFF/Inputs/bar.ll

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define void @bar() { define void @bar() {
ret void ret void
} }

lld/test/COFF/Inputs/conflict.ll

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define void @foo() { define void @foo() {
ret void ret void
} }

lld/test/COFF/Inputs/constant-export.ll

target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" target datalayout = "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:32-n8:16:32-a:0:32-S32"
target triple = "i686-unknown-windows-msvc18.0.0" target triple = "i686-unknown-windows-msvc18.0.0"
@__CFConstantStringClassReference = common global [32 x i32] zeroinitializer, align 4 @__CFConstantStringClassReference = common global [32 x i32] zeroinitializer, align 4
!llvm.linker.options = !{!0} !llvm.linker.options = !{!0}
!0 = !{!" -export:___CFConstantStringClassReference,CONSTANT"} !0 = !{!" -export:___CFConstantStringClassReference,CONSTANT"}

lld/test/COFF/Inputs/entry-mangled.ll

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc18.0.0" target triple = "x86_64-pc-windows-msvc18.0.0"
define void @"\01?main@@YAHXZ"() { define void @"\01?main@@YAHXZ"() {
ret void ret void
} }

lld/test/COFF/Inputs/export.ll

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define void @_DllMainCRTStartup() { define void @_DllMainCRTStartup() {
ret void ret void
} }
define void @exportfn1() { define void @exportfn1() {
ret void ret void
Show All 9 Lines

lld/test/COFF/Inputs/libcall-archive.ll

target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" target datalayout = "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:32-n8:16:32-a:0:32-S32"
target triple = "i686-unknown-windows" target triple = "i686-unknown-windows"
define void @memcpy() { define void @memcpy() {
ret void ret void
} }

lld/test/COFF/Inputs/lto-cache.ll

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define i32 @main() { define i32 @main() {
entry: entry:
call void (...) @globalfunc() call void (...) @globalfunc()
ret i32 0 ret i32 0
} }
declare void @globalfunc(...) declare void @globalfunc(...)

lld/test/COFF/Inputs/lto-comdat1.ll

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
$comdat = comdat any $comdat = comdat any
define void @f1() { define void @f1() {
call void @comdat() call void @comdat()
ret void ret void
} }
define linkonce_odr void @comdat() comdat { define linkonce_odr void @comdat() comdat {
ret void ret void
} }

lld/test/COFF/Inputs/lto-comdat2.ll

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
$comdat = comdat any $comdat = comdat any
define void @f2() { define void @f2() {
call void @comdat() call void @comdat()
ret void ret void
} }
define linkonce_odr void @comdat() comdat { define linkonce_odr void @comdat() comdat {
ret void ret void
} }

lld/test/COFF/Inputs/lto-dep.ll

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define void @foo() { define void @foo() {
ret void ret void
} }
define internal void @internal() { define internal void @internal() {
ret void ret void
} }

lld/test/COFF/Inputs/lto-lazy-reference-dummy.ll

target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" target datalayout = "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:32-n8:16:32-a:0:32-S32"
target triple = "i686-pc-windows-msvc18.0.0" target triple = "i686-pc-windows-msvc18.0.0"
define void @dummy() { define void @dummy() {
ret void ret void
} }

lld/test/COFF/Inputs/lto-lazy-reference-quadruple.ll

target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" target datalayout = "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:32-n8:16:32-a:0:32-S32"
target triple = "i686-pc-windows-msvc18.0.0" target triple = "i686-pc-windows-msvc18.0.0"
define double @quadruple(double %x) { define double @quadruple(double %x) {
entry: entry:
; The symbol __real@40800000 is used to materialize the 4.0 constant. ; The symbol __real@40800000 is used to materialize the 4.0 constant.
%mul = fmul double %x, 4.0 %mul = fmul double %x, 4.0
ret double %mul ret double %mul
} }
declare void @dummy() declare void @dummy()
define void @f() { define void @f() {
call void @dummy() call void @dummy()
ret void ret void
} }

lld/test/COFF/Inputs/msvclto-order-a.ll

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define void @foo() { define void @foo() {
ret void ret void
} }

lld/test/COFF/Inputs/msvclto-order-b.ll

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
declare void @doesntexist() declare void @doesntexist()
define void @foo() { define void @foo() {
call void @doesntexist() call void @doesntexist()
ret void ret void
} }

lld/test/COFF/Inputs/thinlto-empty.ll

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.0.24215" target triple = "x86_64-pc-windows-msvc19.0.24215"

lld/test/COFF/Inputs/thinlto-mangled-qux.ll

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.0.24215" target triple = "x86_64-pc-windows-msvc19.0.24215"
%class.baz = type { %class.bar } %class.baz = type { %class.bar }
%class.bar = type { i32 (...)** } %class.bar = type { i32 (...)** }
$"\01?x@bar@@UEBA_NXZ" = comdat any $"\01?x@bar@@UEBA_NXZ" = comdat any
$"\01??_7baz@@6B@" = comdat any $"\01??_7baz@@6B@" = comdat any
Show All 19 Lines

lld/test/COFF/Inputs/thinlto.ll

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.0.24215" target triple = "x86_64-pc-windows-msvc19.0.24215"
define void @g() { define void @g() {
ret void ret void
} }

lld/test/COFF/Inputs/undefined-symbol-lto-a.ll

; ModuleID = 't.obj' ; ModuleID = 't.obj'
source_filename = "t.cpp" source_filename = "t.cpp"
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.21.27702" target triple = "x86_64-pc-windows-msvc19.21.27702"
%struct.Init = type { %struct.S } %struct.Init = type { %struct.S }
%struct.S = type { i32 (...)** } %struct.S = type { i32 (...)** }
%rtti.CompleteObjectLocator = type { i32, i32, i32, i32, i32, i32 } %rtti.CompleteObjectLocator = type { i32, i32, i32, i32, i32, i32 }
%rtti.TypeDescriptor7 = type { i8**, i8*, [8 x i8] } %rtti.TypeDescriptor7 = type { i8**, i8*, [8 x i8] }
%rtti.ClassHierarchyDescriptor = type { i32, i32, i32, i32 } %rtti.ClassHierarchyDescriptor = type { i32, i32, i32, i32 }
%rtti.BaseClassDescriptor = type { i32, i32, i32, i32, i32, i32, i32 } %rtti.BaseClassDescriptor = type { i32, i32, i32, i32, i32, i32, i32 }
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

lld/test/COFF/Inputs/undefined-symbol-lto-b.ll

; ModuleID = 'b.obj' ; ModuleID = 'b.obj'
source_filename = "b.cpp" source_filename = "b.cpp"
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.21.27702" target triple = "x86_64-pc-windows-msvc19.21.27702"
%struct.S = type { i32 (...)** } %struct.S = type { i32 (...)** }
; Function Attrs: norecurse nounwind readnone sspstrong uwtable ; Function Attrs: norecurse nounwind readnone sspstrong uwtable
define dso_local void @"?foo@S@@UEAAXXZ"(%struct.S* nocapture %this) unnamed_addr #0 align 2 { define dso_local void @"?foo@S@@UEAAXXZ"(%struct.S* nocapture %this) unnamed_addr #0 align 2 {
entry: entry:
ret void ret void
Show All 18 Lines

lld/test/COFF/Inputs/weak-external.ll

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define void @g() { define void @g() {
ret void ret void
} }

lld/test/COFF/Inputs/weak-external2.ll

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define void @f() { define void @f() {
ret void ret void
} }

lld/test/COFF/Inputs/weak-external3.ll

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
@f = weak alias void(), void()* @g @f = weak alias void(), void()* @g
define void @g() { define void @g() {
ret void ret void
} }

lld/test/COFF/entrylib.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as -o %t.obj %s ; RUN: llvm-as -o %t.obj %s
; RUN: rm -f %t.lib ; RUN: rm -f %t.lib
; RUN: llvm-ar cru %t.lib %t.obj ; RUN: llvm-ar cru %t.lib %t.obj
; RUN: lld-link /out:%t.exe /entry:main %t.lib ; RUN: lld-link /out:%t.exe /entry:main %t.lib
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define i32 @main() { define i32 @main() {
ret i32 0 ret i32 0
} }

lld/test/COFF/guardcf-lto.ll

Show All 17 Lines
; CHECK-NEXT: GuardCFFunctionCount: 2 ; CHECK-NEXT: GuardCFFunctionCount: 2
; CHECK-NEXT: GuardFlags: 0x10500 ; CHECK-NEXT: GuardFlags: 0x10500
; CHECK: ] ; CHECK: ]
; CHECK: GuardFidTable [ ; CHECK: GuardFidTable [
; CHECK-NEXT: 0x180{{.*}} ; CHECK-NEXT: 0x180{{.*}}
; CHECK-NEXT: 0x180{{.*}} ; CHECK-NEXT: 0x180{{.*}}
; CHECK-NEXT: ] ; CHECK-NEXT: ]
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.12.25835" target triple = "x86_64-pc-windows-msvc19.12.25835"
declare dllimport void @do_indirect_call(void ()*) declare dllimport void @do_indirect_call(void ()*)
define dso_local i32 @main() local_unnamed_addr { define dso_local i32 @main() local_unnamed_addr {
entry: entry:
tail call void @do_indirect_call(void ()* nonnull @my_handler) tail call void @do_indirect_call(void ()* nonnull @my_handler)
ret i32 0 ret i32 0
} }
define dso_local void @my_handler() { define dso_local void @my_handler() {
entry: entry:
ret void ret void
} }

lld/test/COFF/include-lto.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as -o %t.obj %s ; RUN: llvm-as -o %t.obj %s
; RUN: lld-link /dll /out:%t.dll %t.obj ; RUN: lld-link /dll /out:%t.dll %t.obj
; RUN: llvm-objdump -d %t.dll | FileCheck %s ; RUN: llvm-objdump -d %t.dll | FileCheck %s
; Checks that code for foo is emitted, as required by the /INCLUDE directive. ; Checks that code for foo is emitted, as required by the /INCLUDE directive.
; CHECK: xorl %eax, %eax ; CHECK: xorl %eax, %eax
; CHECK-NEXT: retq ; CHECK-NEXT: retq
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define void @_DllMainCRTStartup() { define void @_DllMainCRTStartup() {
ret void ret void
} }
define i32 @foo() { define i32 @foo() {
ret i32 0 ret i32 0
} }
!llvm.linker.options = !{!0} !llvm.linker.options = !{!0}
!0 = !{!"/INCLUDE:foo"} !0 = !{!"/INCLUDE:foo"}

lld/test/COFF/lib-module-asm.ll

; REQUIRES: x86 ; REQUIRES: x86
; PR41803: llvm-link /lib on object with module asm crashes ; PR41803: llvm-link /lib on object with module asm crashes
; RUN: rm -f %t.lib ; RUN: rm -f %t.lib
; RUN: llvm-as -o %t.obj %s ; RUN: llvm-as -o %t.obj %s
; RUN: lld-link /lib /out:%t.lib %t.obj ; RUN: lld-link /lib /out:%t.lib %t.obj
; RUN: llvm-nm -M %t.lib | FileCheck %s ; RUN: llvm-nm -M %t.lib | FileCheck %s
target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" target datalayout = "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:32-n8:16:32-a:0:32-S32"
target triple = "i386-pc-windows-msvc19.11.0" target triple = "i386-pc-windows-msvc19.11.0"
module asm ".global global_asm_sym" module asm ".global global_asm_sym"
module asm "global_asm_sym:" module asm "global_asm_sym:"
module asm "local_asm_sym:" module asm "local_asm_sym:"
module asm ".long undef_asm_sym" module asm ".long undef_asm_sym"
; CHECK: Archive map ; CHECK: Archive map
; CHECK-NEXT: global_asm_sym in {{.*}}lib-module-asm.ll.tmp.obj ; CHECK-NEXT: global_asm_sym in {{.*}}lib-module-asm.ll.tmp.obj
; CHECK: lib-module-asm.ll.tmp.obj:{{$}} ; CHECK: lib-module-asm.ll.tmp.obj:{{$}}
; CHECK-NEXT: T global_asm_sym ; CHECK-NEXT: T global_asm_sym
; CHECK-NEXT: t local_asm_sym ; CHECK-NEXT: t local_asm_sym
; CHECK-NEXT: U undef_asm_sym ; CHECK-NEXT: U undef_asm_sym

lld/test/COFF/libcall-archive.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: rm -f %t.a ; RUN: rm -f %t.a
; RUN: llvm-as -o %t.obj %s ; RUN: llvm-as -o %t.obj %s
; RUN: llvm-as -o %t2.obj %S/Inputs/libcall-archive.ll ; RUN: llvm-as -o %t2.obj %S/Inputs/libcall-archive.ll
; RUN: llvm-mc -filetype=obj -triple=i686-unknown-windows -o %t3.obj %S/Inputs/libcall-archive.s ; RUN: llvm-mc -filetype=obj -triple=i686-unknown-windows -o %t3.obj %S/Inputs/libcall-archive.s
; RUN: llvm-ar rcs %t.a %t2.obj %t3.obj ; RUN: llvm-ar rcs %t.a %t2.obj %t3.obj
; RUN: lld-link -out:%t.exe -subsystem:console -entry:start -safeseh:no -lldmap:- %t.obj %t.a | FileCheck %s ; RUN: lld-link -out:%t.exe -subsystem:console -entry:start -safeseh:no -lldmap:- %t.obj %t.a | FileCheck %s
; CHECK-NOT: ___sync_val_compare_and_swap_8 ; CHECK-NOT: ___sync_val_compare_and_swap_8
; CHECK: _start ; CHECK: _start
; CHECK: _memcpy ; CHECK: _memcpy
target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" target datalayout = "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:32-n8:16:32-a:0:32-S32"
target triple = "i686-unknown-windows" target triple = "i686-unknown-windows"
define void @start(i8* %a, i8* %b) { define void @start(i8* %a, i8* %b) {
entry: entry:
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 1024, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 1024, i1 false)
ret void ret void
} }
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1)

lld/test/COFF/loadcfg.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as -o %t.obj %s ; RUN: llvm-as -o %t.obj %s
; RUN: lld-link /out:%t.exe %t.obj /entry:main /subsystem:console ; RUN: lld-link /out:%t.exe %t.obj /entry:main /subsystem:console
; RUN: llvm-readobj --file-headers %t.exe | FileCheck %s ; RUN: llvm-readobj --file-headers %t.exe | FileCheck %s
; CHECK: LoadConfigTableRVA: 0x2000 ; CHECK: LoadConfigTableRVA: 0x2000
; CHECK: LoadConfigTableSize: 0x70 ; CHECK: LoadConfigTableSize: 0x70
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
@_load_config_used = constant [28 x i32] [i32 112, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0] @_load_config_used = constant [28 x i32] [i32 112, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0]
define void @main() { define void @main() {
ret void ret void
} }

lld/test/COFF/lto-cache.ll

; REQUIRES: x86 ; REQUIRES: x86
; NetBSD: noatime mounts currently inhibit 'touch' from updating atime ; NetBSD: noatime mounts currently inhibit 'touch' from updating atime
; UNSUPPORTED: system-netbsd ; UNSUPPORTED: system-netbsd
; RUN: opt -module-hash -module-summary %s -o %t.o ; RUN: opt -module-hash -module-summary %s -o %t.o
; RUN: opt -module-hash -module-summary %p/Inputs/lto-cache.ll -o %t2.o ; RUN: opt -module-hash -module-summary %p/Inputs/lto-cache.ll -o %t2.o
; RUN: rm -Rf %t.cache && mkdir %t.cache ; RUN: rm -Rf %t.cache && mkdir %t.cache
; Create two files that would be removed by cache pruning due to age. ; Create two files that would be removed by cache pruning due to age.
; We should only remove files matching the pattern "llvmcache-*". ; We should only remove files matching the pattern "llvmcache-*".
; RUN: touch -t 197001011200 %t.cache/llvmcache-foo %t.cache/foo ; RUN: touch -t 197001011200 %t.cache/llvmcache-foo %t.cache/foo
; RUN: lld-link /lldltocache:%t.cache /lldltocachepolicy:prune_after=1h /out:%t3 /entry:main %t2.o %t.o ; RUN: lld-link /lldltocache:%t.cache /lldltocachepolicy:prune_after=1h /out:%t3 /entry:main %t2.o %t.o
; Two cached objects, plus a timestamp file and "foo", minus the file we removed. ; Two cached objects, plus a timestamp file and "foo", minus the file we removed.
; RUN: ls %t.cache | count 4 ; RUN: ls %t.cache | count 4
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define void @globalfunc() #0 { define void @globalfunc() #0 {
entry: entry:
ret void ret void
} }

lld/test/COFF/lto-chkstk.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as -o %t.obj %s ; RUN: llvm-as -o %t.obj %s
; RUN: llvm-mc -triple=x86_64-pc-windows-msvc -filetype=obj -o %T/lto-chkstk-foo.obj %S/Inputs/lto-chkstk-foo.s ; RUN: llvm-mc -triple=x86_64-pc-windows-msvc -filetype=obj -o %T/lto-chkstk-foo.obj %S/Inputs/lto-chkstk-foo.s
; RUN: llvm-mc -triple=x86_64-pc-windows-msvc -filetype=obj -o %T/lto-chkstk-chkstk.obj %S/Inputs/lto-chkstk-chkstk.s ; RUN: llvm-mc -triple=x86_64-pc-windows-msvc -filetype=obj -o %T/lto-chkstk-chkstk.obj %S/Inputs/lto-chkstk-chkstk.s
; RUN: rm -f %t.lib ; RUN: rm -f %t.lib
; RUN: llvm-ar cru %t.lib %T/lto-chkstk-chkstk.obj ; RUN: llvm-ar cru %t.lib %T/lto-chkstk-chkstk.obj
; RUN: lld-link /out:%t.exe /entry:main /subsystem:console %t.obj %T/lto-chkstk-foo.obj %t.lib ; RUN: lld-link /out:%t.exe /entry:main /subsystem:console %t.obj %T/lto-chkstk-foo.obj %t.lib
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define void @main() { define void @main() {
entry: entry:
%array4096 = alloca [4096 x i8] %array4096 = alloca [4096 x i8]
call void @foo([4096 x i8]* %array4096) call void @foo([4096 x i8]* %array4096)
ret void ret void
} }
declare void @foo([4096 x i8]*) declare void @foo([4096 x i8]*)

lld/test/COFF/lto-comdat.ll

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
; TEXT-10-NEXT: callq -30 ; TEXT-10-NEXT: callq -30
; TEXT-10-NEXT: xorl %eax, %eax ; TEXT-10-NEXT: xorl %eax, %eax
; TEXT-10-NEXT: addq $40, %rsp ; TEXT-10-NEXT: addq $40, %rsp
; TEXT-10-NEXT: retq ; TEXT-10-NEXT: retq
; TEXT-10-NOT: callq ; TEXT-10-NOT: callq
; TEXT-10: retq ; TEXT-10: retq
; TEXT-10-NOT: {{.}} ; TEXT-10-NOT: {{.}}
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
$comdat = comdat any $comdat = comdat any
define i32 @main() { define i32 @main() {
call void @f1() call void @f1()
call void @f2() call void @f2()
call void @comdat() call void @comdat()
Show All 9 Lines

lld/test/COFF/lto-cpu-string.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.obj ; RUN: llvm-as %s -o %t.obj
; RUN: lld-link %t.obj -noentry -nodefaultlib -out:%t.dll -dll ; RUN: lld-link %t.obj -noentry -nodefaultlib -out:%t.dll -dll
; RUN: llvm-objdump -d -section=".text" -no-leading-addr -no-show-raw-insn %t.dll | FileCheck %s ; RUN: llvm-objdump -d -section=".text" -no-leading-addr -no-show-raw-insn %t.dll | FileCheck %s
; CHECK: nop{{$}} ; CHECK: nop{{$}}
; RUN: lld-link -mllvm:-mcpu=znver1 -noentry -nodefaultlib %t.obj -out:%t.znver1.dll -dll ; RUN: lld-link -mllvm:-mcpu=znver1 -noentry -nodefaultlib %t.obj -out:%t.znver1.dll -dll
; RUN: llvm-objdump -d -section=".text" -no-leading-addr -no-show-raw-insn %t.znver1.dll | FileCheck -check-prefix=ZNVER1 %s ; RUN: llvm-objdump -d -section=".text" -no-leading-addr -no-show-raw-insn %t.znver1.dll | FileCheck -check-prefix=ZNVER1 %s
; ZNVER1: nopw ; ZNVER1: nopw
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.14.26433" target triple = "x86_64-pc-windows-msvc19.14.26433"
define dllexport void @foo() #0 { define dllexport void @foo() #0 {
entry: entry:
call void asm sideeffect ".p2align 4, 0x90", "~{dirflag},~{fpsr},~{flags}"() call void asm sideeffect ".p2align 4, 0x90", "~{dirflag},~{fpsr},~{flags}"()
ret void ret void
} }
attributes #0 = { "no-frame-pointer-elim"="true" } attributes #0 = { "no-frame-pointer-elim"="true" }

lld/test/COFF/lto-debug-pass-arguments.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.obj ; RUN: llvm-as %s -o %t.obj
; RUN: lld-link /dll /out:%t.dll %t.obj /mllvm:-debug-pass=Arguments 2>&1 | FileCheck %s ; RUN: lld-link /dll /out:%t.dll %t.obj /mllvm:-debug-pass=Arguments 2>&1 | FileCheck %s
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define void @dummy() { define void @dummy() {
ret void ret void
} }
define void @_DllMainCRTStartup() { define void @_DllMainCRTStartup() {
ret void ret void
} }
; CHECK: Pass Arguments: ; CHECK: Pass Arguments:

lld/test/COFF/lto-icf.ll

; REQUIRES: x86 ; REQUIRES: x86
; Test that ICF works after LTO, i.e. both functions have the same address. ; Test that ICF works after LTO, i.e. both functions have the same address.
; Previously, when we didn't enable function sections, ICF didn't work. ; Previously, when we didn't enable function sections, ICF didn't work.
; RUN: llvm-as %s -o %t.bc ; RUN: llvm-as %s -o %t.bc
; RUN: lld-link -opt:icf -dll -noentry %t.bc -out:%t.dll ; RUN: lld-link -opt:icf -dll -noentry %t.bc -out:%t.dll
; RUN: llvm-readobj --coff-exports %t.dll | FileCheck %s ; RUN: llvm-readobj --coff-exports %t.dll | FileCheck %s
; CHECK: Export { ; CHECK: Export {
; CHECK: Export { ; CHECK: Export {
; CHECK: RVA: 0x[[RVA:.*]] ; CHECK: RVA: 0x[[RVA:.*]]
; CHECK: Export { ; CHECK: Export {
; CHECK: RVA: 0x[[RVA]] ; CHECK: RVA: 0x[[RVA]]
; CHECK-NOT: Export ; CHECK-NOT: Export
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.12.25835" target triple = "x86_64-pc-windows-msvc19.12.25835"
define dllexport i8* @icf_ptr() { define dllexport i8* @icf_ptr() {
entry: entry:
ret i8* null ret i8* null
} }
define dllexport i64 @icf_int() { define dllexport i64 @icf_int() {
entry: entry:
ret i64 0 ret i64 0
} }

lld/test/COFF/lto-lazy-reference.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llc -mtriple=i686-pc-windows-msvc -filetype=obj -o %T/lto-lazy-reference-quadruple.obj %S/Inputs/lto-lazy-reference-quadruple.ll ; RUN: llc -mtriple=i686-pc-windows-msvc -filetype=obj -o %T/lto-lazy-reference-quadruple.obj %S/Inputs/lto-lazy-reference-quadruple.ll
; RUN: llvm-as -o %T/lto-lazy-reference-dummy.bc %S/Inputs/lto-lazy-reference-dummy.ll ; RUN: llvm-as -o %T/lto-lazy-reference-dummy.bc %S/Inputs/lto-lazy-reference-dummy.ll
; RUN: rm -f %t.lib ; RUN: rm -f %t.lib
; RUN: llvm-ar cru %t.lib %T/lto-lazy-reference-quadruple.obj %T/lto-lazy-reference-dummy.bc ; RUN: llvm-ar cru %t.lib %T/lto-lazy-reference-quadruple.obj %T/lto-lazy-reference-dummy.bc
; RUN: llvm-as -o %t.obj %s ; RUN: llvm-as -o %t.obj %s
; RUN: lld-link /out:%t.exe /entry:main /subsystem:console %t.obj %t.lib ; RUN: lld-link /out:%t.exe /entry:main /subsystem:console %t.obj %t.lib
target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" target datalayout = "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:32-n8:16:32-a:0:32-S32"
target triple = "i686-pc-windows-msvc18.0.0" target triple = "i686-pc-windows-msvc18.0.0"
; Define fltused, since we don't link against the MS C runtime but are ; Define fltused, since we don't link against the MS C runtime but are
; using floats. ; using floats.
@_fltused = dllexport global i32 0, align 4 @_fltused = dllexport global i32 0, align 4
define double @main(double %x) { define double @main(double %x) {
entry: entry:
Show All 9 Lines

lld/test/COFF/lto-linker-opts.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as -o %T/lto-linker-opts.obj %s ; RUN: llvm-as -o %T/lto-linker-opts.obj %s
; RUN: env LIB=%S/Inputs lld-link /out:%T/lto-linker-opts.exe /entry:main /subsystem:console %T/lto-linker-opts.obj ; RUN: env LIB=%S/Inputs lld-link /out:%T/lto-linker-opts.exe /entry:main /subsystem:console %T/lto-linker-opts.obj
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
!llvm.linker.options = !{!0} !llvm.linker.options = !{!0}
!0 = !{!"/DEFAULTLIB:ret42.lib"} !0 = !{!"/DEFAULTLIB:ret42.lib"}

lld/test/COFF/lto-new-symbol.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as -o %t.obj %s ; RUN: llvm-as -o %t.obj %s
; RUN: lld-link /out:%t.exe /entry:foo /subsystem:console %t.obj ; RUN: lld-link /out:%t.exe /entry:foo /subsystem:console %t.obj
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
; Define fltused, since we don't link against the MS C runtime but are ; Define fltused, since we don't link against the MS C runtime but are
; using floats. ; using floats.
@_fltused = dllexport global i32 0, align 4 @_fltused = dllexport global i32 0, align 4
define void @foo(<4 x i32>* %p, <4 x float>* %q, i1 %t) nounwind { define void @foo(<4 x i32>* %p, <4 x float>* %q, i1 %t) nounwind {
entry: entry:
br label %loop br label %loop
loop: loop:
store <4 x i32><i32 1073741824, i32 1073741824, i32 1073741824, i32 1073741824>, <4 x i32>* %p store <4 x i32><i32 1073741824, i32 1073741824, i32 1073741824, i32 1073741824>, <4 x i32>* %p
store <4 x float><float 2.0, float 2.0, float 2.0, float 2.0>, <4 x float>* %q store <4 x float><float 2.0, float 2.0, float 2.0, float 2.0>, <4 x float>* %q
br i1 %t, label %loop, label %ret br i1 %t, label %loop, label %ret
ret: ret:
ret void ret void
} }

lld/test/COFF/lto-obj-path.ll

; REQUIRES: x86 ; REQUIRES: x86
; Test to ensure that thinlto-index-only with lto-obj-path creates ; Test to ensure that thinlto-index-only with lto-obj-path creates
; the native object file. ; the native object file.
; RUN: opt -module-summary %s -o %t1.obj ; RUN: opt -module-summary %s -o %t1.obj
; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.obj ; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.obj
; RUN: rm -f %t4.obj ; RUN: rm -f %t4.obj
; RUN: lld-link -thinlto-index-only -lto-obj-path:%t4.obj -out:t3.exe \ ; RUN: lld-link -thinlto-index-only -lto-obj-path:%t4.obj -out:t3.exe \
; RUN: -entry:main %t1.obj %t2.obj ; RUN: -entry:main %t1.obj %t2.obj
; RUN: llvm-readobj -h %t4.obj | FileCheck %s ; RUN: llvm-readobj -h %t4.obj | FileCheck %s
; RUN: llvm-nm %t4.obj 2>&1 | FileCheck %s -check-prefix=SYMBOLS ; RUN: llvm-nm %t4.obj 2>&1 | FileCheck %s -check-prefix=SYMBOLS
; RUN: llvm-nm %t4.obj 2>&1 | count 1 ; RUN: llvm-nm %t4.obj 2>&1 | count 1
; CHECK: Format: COFF-x86-64 ; CHECK: Format: COFF-x86-64
; SYMBOLS: @feat.00 ; SYMBOLS: @feat.00
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.0.24215" target triple = "x86_64-pc-windows-msvc19.0.24215"
declare void @g(...) declare void @g(...)
define void @main() { define void @main() {
call void (...) @g() call void (...) @g()
ret void ret void
} }

lld/test/COFF/lto-opt-level.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as -o %t.obj %s ; RUN: llvm-as -o %t.obj %s
; RUN: lld-link /out:%t0.exe /entry:main /subsystem:console /opt:lldlto=0 /lldmap:%t0.map %t.obj ; RUN: lld-link /out:%t0.exe /entry:main /subsystem:console /opt:lldlto=0 /lldmap:%t0.map %t.obj
; RUN: FileCheck --check-prefix=CHECK-O0 %s < %t0.map ; RUN: FileCheck --check-prefix=CHECK-O0 %s < %t0.map
; RUN: lld-link /out:%t2.exe /entry:main /subsystem:console /opt:lldlto=2 /lldmap:%t2.map %t.obj ; RUN: lld-link /out:%t2.exe /entry:main /subsystem:console /opt:lldlto=2 /lldmap:%t2.map %t.obj
; RUN: FileCheck --check-prefix=CHECK-O2 %s < %t2.map ; RUN: FileCheck --check-prefix=CHECK-O2 %s < %t2.map
; RUN: lld-link /out:%t2a.exe /entry:main /subsystem:console /lldmap:%t2a.map %t.obj ; RUN: lld-link /out:%t2a.exe /entry:main /subsystem:console /lldmap:%t2a.map %t.obj
; RUN: FileCheck --check-prefix=CHECK-O2 %s < %t2a.map ; RUN: FileCheck --check-prefix=CHECK-O2 %s < %t2a.map
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
; CHECK-O0: foo ; CHECK-O0: foo
; CHECK-O2-NOT: foo ; CHECK-O2-NOT: foo
define internal void @foo() { define internal void @foo() {
ret void ret void
} }
define void @main() { define void @main() {
call void @foo() call void @foo()
ret void ret void
} }

lld/test/COFF/lto-parallel.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as -o %t.obj %s ; RUN: llvm-as -o %t.obj %s
; RUN: lld-link -opt:noicf /out:%t.exe /entry:foo /include:bar /opt:lldltopartitions=2 /subsystem:console /lldmap:%t.map %t.obj ; RUN: lld-link -opt:noicf /out:%t.exe /entry:foo /include:bar /opt:lldltopartitions=2 /subsystem:console /lldmap:%t.map %t.obj
; RUN: FileCheck %s < %t.map ; RUN: FileCheck %s < %t.map
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
; CHECK: lto.tmp ; CHECK: lto.tmp
; CHECK: lto.tmp ; CHECK: lto.tmp
; CHECK-NEXT: foo ; CHECK-NEXT: foo
define void @foo() { define void @foo() {
call void @bar() call void @bar()
ret void ret void
Show All 9 Lines

lld/test/COFF/lto-reloc-model.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as -o %t %s ; RUN: llvm-as -o %t %s
; RUN: lld-link /entry:main /subsystem:console /out:%t.exe %t ; RUN: lld-link /entry:main /subsystem:console /out:%t.exe %t
; RUN: llvm-objdump -d %t.exe | FileCheck %s ; RUN: llvm-objdump -d %t.exe | FileCheck %s
target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" target datalayout = "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:32-n8:16:32-a:0:32-S32"
target triple = "i686-pc-windows-msvc" target triple = "i686-pc-windows-msvc"
@foo = thread_local global i8 0 @foo = thread_local global i8 0
module asm "__tls_index = 1" module asm "__tls_index = 1"
module asm "__tls_array = 2" module asm "__tls_array = 2"
define i8* @main() { define i8* @main() {
; CHECK: movl 1, %eax ; CHECK: movl 1, %eax
; CHECK: movl %fs:2, %ecx ; CHECK: movl %fs:2, %ecx
; CHECK: movl (%ecx,%eax,4), %eax ; CHECK: movl (%ecx,%eax,4), %eax
; CHECK: leal (%eax), %eax ; CHECK: leal (%eax), %eax
ret i8* @foo ret i8* @foo
} }

lld/test/COFF/lto.ll

Show First 20 Lines • Show All 117 Lines • ▼ Show 20 Lines
; TEXT-10-NEXT: int3 ; TEXT-10-NEXT: int3
; TEXT-10-NEXT: int3 ; TEXT-10-NEXT: int3
; TEXT-10-NEXT: subq $40, %rsp ; TEXT-10-NEXT: subq $40, %rsp
; TEXT-10-NEXT: callq -41 ; TEXT-10-NEXT: callq -41
; TEXT-10-NEXT: xorl %eax, %eax ; TEXT-10-NEXT: xorl %eax, %eax
; TEXT-10-NEXT: addq $40, %rsp ; TEXT-10-NEXT: addq $40, %rsp
; TEXT-10-NEXT: retq ; TEXT-10-NEXT: retq
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define i32 @main() { define i32 @main() {
call void @foo() call void @foo()
ret i32 0 ret i32 0
} }
declare void @foo() declare void @foo()
Show All 14 Lines

lld/test/COFF/savetemps.ll

Show All 15 Lines
; RUN: llvm-dis -o - %T/savetemps/savetemps.exe.0.4.opt.bc | FileCheck %s ; RUN: llvm-dis -o - %T/savetemps/savetemps.exe.0.4.opt.bc | FileCheck %s
; RUN: llvm-dis -o - %T/savetemps/savetemps.exe.0.5.precodegen.bc | FileCheck %s ; RUN: llvm-dis -o - %T/savetemps/savetemps.exe.0.5.precodegen.bc | FileCheck %s
; RUN: llvm-objdump -s %T/savetemps/savetemps.exe.lto.obj | \ ; RUN: llvm-objdump -s %T/savetemps/savetemps.exe.lto.obj | \
; RUN: FileCheck --check-prefix=CHECK-OBJDUMP %s ; RUN: FileCheck --check-prefix=CHECK-OBJDUMP %s
; CHECK: define i32 @main() ; CHECK: define i32 @main()
; CHECK-OBJDUMP: file format COFF ; CHECK-OBJDUMP: file format COFF
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define i32 @main() { define i32 @main() {
ret i32 0 ret i32 0
} }

lld/test/COFF/thinlto-archivecollision.ll

Show All 10 Lines
; CHECK: {{/|\\\\thinlto-archivecollision.ll.tmp/main.obj$}} ; CHECK: {{/|\\\\thinlto-archivecollision.ll.tmp/main.obj$}}
; CHECK: {{^-r=.*/|\\\\thinlto-archivecollision.ll.tmp/main.obj,main,px$}} ; CHECK: {{^-r=.*/|\\\\thinlto-archivecollision.ll.tmp/main.obj,main,px$}}
; CHECK: {{/|\\\\thinlto-archivecollision.ll.tmp/libbar.libbar.obj[0-9]+$}} ; CHECK: {{/|\\\\thinlto-archivecollision.ll.tmp/libbar.libbar.obj[0-9]+$}}
; CHECK-NEXT: {{^-r=.*/|\\\\thinlto-archivecollision.ll.tmp/libbar.libbar.obj[0-9]+,foo,p$}} ; CHECK-NEXT: {{^-r=.*/|\\\\thinlto-archivecollision.ll.tmp/libbar.libbar.obj[0-9]+,foo,p$}}
; CHECK-NEXT: {{/|\\\\thinlto-archivecollision.ll.tmp/libbar.libbar.obj[0-9]+$}} ; CHECK-NEXT: {{/|\\\\thinlto-archivecollision.ll.tmp/libbar.libbar.obj[0-9]+$}}
; CHECK-NEXT: {{^-r=.*/|\\\\thinlto-archivecollision.ll.tmp/libbar.libbar.obj[0-9]+,bar,p$}} ; CHECK-NEXT: {{^-r=.*/|\\\\thinlto-archivecollision.ll.tmp/libbar.libbar.obj[0-9]+,bar,p$}}
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
declare void @bar() declare void @bar()
declare void @foo() declare void @foo()
define i32 @main() { define i32 @main() {
call void @foo() call void @foo()
call void @bar() call void @bar()
ret i32 0 ret i32 0
} }

lld/test/COFF/thinlto-archives.ll

Show All 12 Lines
; CHECK: {{/thinlto-archives/main.obj$}} ; CHECK: {{/thinlto-archives/main.obj$}}
; CHECK: {{^-r=.*/thinlto-archives/main.obj,main,px$}} ; CHECK: {{^-r=.*/thinlto-archives/main.obj,main,px$}}
; CHECK: {{/thinlto-archives/a.libbar.obj[0-9]+$}} ; CHECK: {{/thinlto-archives/a.libbar.obj[0-9]+$}}
; CHECK-NEXT: {{^-r=.*/thinlto-archives/a.libbar.obj[0-9]+,foo,p$}} ; CHECK-NEXT: {{^-r=.*/thinlto-archives/a.libbar.obj[0-9]+,foo,p$}}
; CHECK-NEXT: {{/thinlto-archives/b.libbar.obj[0-9]+$}} ; CHECK-NEXT: {{/thinlto-archives/b.libbar.obj[0-9]+$}}
; CHECK-NEXT: {{^-r=.*/thinlto-archives/b.libbar.obj[0-9]+,bar,p$}} ; CHECK-NEXT: {{^-r=.*/thinlto-archives/b.libbar.obj[0-9]+,bar,p$}}
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
declare void @bar() declare void @bar()
declare void @foo() declare void @foo()
define i32 @main() { define i32 @main() {
call void @foo() call void @foo()
call void @bar() call void @bar()
ret i32 0 ret i32 0
} }

lld/test/COFF/thinlto-emit-imports.ll

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
; RUN: rm -f %t2.obj.imports ; RUN: rm -f %t2.obj.imports
; RUN: rm -f %t3.obj.imports ; RUN: rm -f %t3.obj.imports
; RUN: lld-link -entry:main -thinlto-emit-imports-files \ ; RUN: lld-link -entry:main -thinlto-emit-imports-files \
; RUN: %t1.obj %t2.obj %t3.obj -out:%t4.exe ; RUN: %t1.obj %t2.obj %t3.obj -out:%t4.exe
; RUN: not ls %t1.obj.imports ; RUN: not ls %t1.obj.imports
; RUN: not ls %t2.obj.imports ; RUN: not ls %t2.obj.imports
; RUN: not ls %t3.obj.imports ; RUN: not ls %t3.obj.imports
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.0.24215" target triple = "x86_64-pc-windows-msvc19.0.24215"
declare void @g(...) declare void @g(...)
define void @main() { define void @main() {
entry: entry:
call void (...) @g() call void (...) @g()
ret void ret void
} }

lld/test/COFF/thinlto-index-only.ll

Show All 35 Lines
; BACKEND2: </MODULE_STRTAB_BLOCK ; BACKEND2: </MODULE_STRTAB_BLOCK
; BACKEND2-NEXT: <GLOBALVAL_SUMMARY_BLOCK ; BACKEND2-NEXT: <GLOBALVAL_SUMMARY_BLOCK
; BACKEND2-NEXT: <VERSION ; BACKEND2-NEXT: <VERSION
; BACKEND2-NEXT: <FLAGS ; BACKEND2-NEXT: <FLAGS
; BACKEND2-NEXT: <VALUE_GUID op0=1 op1=-5300342847281564238 ; BACKEND2-NEXT: <VALUE_GUID op0=1 op1=-5300342847281564238
; BACKEND2-NEXT: <COMBINED ; BACKEND2-NEXT: <COMBINED
; BACKEND2-NEXT: </GLOBALVAL_SUMMARY_BLOCK ; BACKEND2-NEXT: </GLOBALVAL_SUMMARY_BLOCK
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.0.24215" target triple = "x86_64-pc-windows-msvc19.0.24215"
declare void @g(...) declare void @g(...)
define void @main() { define void @main() {
call void (...) @g() call void (...) @g()
ret void ret void
} }

lld/test/COFF/thinlto-mangled.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: opt -thinlto-bc %s -o %t.obj ; RUN: opt -thinlto-bc %s -o %t.obj
; RUN: opt -thinlto-bc %S/Inputs/thinlto-mangled-qux.ll -o %T/thinlto-mangled-qux.obj ; RUN: opt -thinlto-bc %S/Inputs/thinlto-mangled-qux.ll -o %T/thinlto-mangled-qux.obj
; RUN: lld-link -out:%t.exe -entry:main %t.obj %T/thinlto-mangled-qux.obj ; RUN: lld-link -out:%t.exe -entry:main %t.obj %T/thinlto-mangled-qux.obj
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.0.24215" target triple = "x86_64-pc-windows-msvc19.0.24215"
%"class.bar" = type { i32 (...)**, i8*, i8*, i8*, i32 } %"class.bar" = type { i32 (...)**, i8*, i8*, i8*, i32 }
define i32 @main() { define i32 @main() {
ret i32 0 ret i32 0
} }
define available_externally zeroext i1 @"\01?x@bar@@UEBA_NXZ"(%"class.bar"* %this) unnamed_addr align 2 { define available_externally zeroext i1 @"\01?x@bar@@UEBA_NXZ"(%"class.bar"* %this) unnamed_addr align 2 {
ret i1 false ret i1 false
} }

lld/test/COFF/thinlto-object-suffix-replace.ll

Show All 30 Lines
; If filename does not end with old suffix, no suffix change should occur, ; If filename does not end with old suffix, no suffix change should occur,
; so ".thinlto.bc" will simply be appended to the input file name. ; so ".thinlto.bc" will simply be appended to the input file name.
; RUN: rm -f %t1.thinlink.bc.thinlto.bc ; RUN: rm -f %t1.thinlink.bc.thinlto.bc
; RUN: lld-link -entry:main -thinlto-index-only \ ; RUN: lld-link -entry:main -thinlto-index-only \
; RUN: -thinlto-object-suffix-replace:".abc;.obj" %t1.thinlink.bc -out:%t3.exe ; RUN: -thinlto-object-suffix-replace:".abc;.obj" %t1.thinlink.bc -out:%t3.exe
; RUN: ls %t1.thinlink.bc.thinlto.bc ; RUN: ls %t1.thinlink.bc.thinlto.bc
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.0.24215" target triple = "x86_64-pc-windows-msvc19.0.24215"
define void @main() { define void @main() {
entry: entry:
ret void ret void
} }
!llvm.dbg.cu = !{} !llvm.dbg.cu = !{}
!1 = !{i32 2, !"Debug Info Version", i32 3} !1 = !{i32 2, !"Debug Info Version", i32 3}
!llvm.module.flags = !{!1} !llvm.module.flags = !{!1}

lld/test/COFF/thinlto-prefix-replace.ll

Show All 12 Lines
; Ensure that lld errors if prefix replace option is not in 'old;new' format. ; Ensure that lld errors if prefix replace option is not in 'old;new' format.
; RUN: rm -f %t/newpath/t.obj.thinlto.bc ; RUN: rm -f %t/newpath/t.obj.thinlto.bc
; RUN: not lld-link -entry:main -thinlto-index-only \ ; RUN: not lld-link -entry:main -thinlto-index-only \
; RUN: -thinlto-prefix-replace:"abc:def" %t/oldpath/t.obj \ ; RUN: -thinlto-prefix-replace:"abc:def" %t/oldpath/t.obj \
; RUN: -out:%t/t.exe 2>&1 | FileCheck --check-prefix=ERR %s ; RUN: -out:%t/t.exe 2>&1 | FileCheck --check-prefix=ERR %s
; ERR: -thinlto-prefix-replace: expects 'old;new' format, but got abc:def ; ERR: -thinlto-prefix-replace: expects 'old;new' format, but got abc:def
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.0.24215" target triple = "x86_64-pc-windows-msvc19.0.24215"
define void @main() { define void @main() {
ret void ret void
} }

lld/test/COFF/thinlto.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: rm -fr %T/thinlto ; RUN: rm -fr %T/thinlto
; RUN: mkdir %T/thinlto ; RUN: mkdir %T/thinlto
; RUN: opt -thinlto-bc -o %T/thinlto/main.obj %s ; RUN: opt -thinlto-bc -o %T/thinlto/main.obj %s
; RUN: opt -thinlto-bc -o %T/thinlto/foo.obj %S/Inputs/lto-dep.ll ; RUN: opt -thinlto-bc -o %T/thinlto/foo.obj %S/Inputs/lto-dep.ll
; RUN: lld-link /lldsavetemps /out:%T/thinlto/main.exe /entry:main /subsystem:console %T/thinlto/main.obj %T/thinlto/foo.obj ; RUN: lld-link /lldsavetemps /out:%T/thinlto/main.exe /entry:main /subsystem:console %T/thinlto/main.obj %T/thinlto/foo.obj
; RUN: llvm-nm %T/thinlto/main.exe1.lto.obj | FileCheck %s ; RUN: llvm-nm %T/thinlto/main.exe1.lto.obj | FileCheck %s
; CHECK-NOT: U foo ; CHECK-NOT: U foo
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define i32 @main() { define i32 @main() {
call void @foo() call void @foo()
ret i32 0 ret i32 0
} }
declare void @foo() declare void @foo()

lld/test/COFF/unresolved-lto-bitcode.ll

Show All 11 Lines
; object files we created are present in the directory (indicating that ; object files we created are present in the directory (indicating that
; LTO did not run). ; LTO did not run).
; CHECK: undefined symbol: bar ; CHECK: undefined symbol: bar
; CHECK: referenced by {{.*}}unresolved-lto-bitcode.ll ; CHECK: referenced by {{.*}}unresolved-lto-bitcode.ll
; CHECK: >>> {{.*}}unresolved-lto-bitcode.ll.tmp/main.obj ; CHECK: >>> {{.*}}unresolved-lto-bitcode.ll.tmp/main.obj
; FILE: foo.obj ; FILE: foo.obj
; FILE: main.obj ; FILE: main.obj
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define i32 @main() { define i32 @main() {
call void @foo() call void @foo()
call void @bar() call void @bar()
ret i32 0 ret i32 0
} }
declare void @bar() declare void @bar()
declare void @foo() declare void @foo()

lld/test/COFF/unresolved-lto.ll

Show All 10 Lines
; Check that the undefined symbol is reported, and that only the two ; Check that the undefined symbol is reported, and that only the two
; object files we created are present in the directory (indicating that ; object files we created are present in the directory (indicating that
; LTO did not run). ; LTO did not run).
; CHECK: undefined symbol: bar ; CHECK: undefined symbol: bar
; CHECK: referenced by {{.*}}main.obj ; CHECK: referenced by {{.*}}main.obj
; FILE: foo.obj ; FILE: foo.obj
; FILE: main.obj ; FILE: main.obj
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define i32 @main() { define i32 @main() {
call void @foo() call void @foo()
call void @bar() call void @bar()
ret i32 0 ret i32 0
} }
declare void @bar() declare void @bar()
declare void @foo() declare void @foo()

lld/test/COFF/used-lto.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as -o %t.obj %s ; RUN: llvm-as -o %t.obj %s
; RUN: lld-link -dll -debug -opt:ref -noentry -out:%t.dll %t.obj ; RUN: lld-link -dll -debug -opt:ref -noentry -out:%t.dll %t.obj
; RUN: llvm-pdbutil dump -publics %t.pdb | FileCheck %s ; RUN: llvm-pdbutil dump -publics %t.pdb | FileCheck %s
; CHECK: S_PUB32 {{.*}} `foo` ; CHECK: S_PUB32 {{.*}} `foo`
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
@llvm.used = appending global [1 x i8*] [i8* bitcast (void ()* @foo to i8*)], section "llvm.metadata" @llvm.used = appending global [1 x i8*] [i8* bitcast (void ()* @foo to i8*)], section "llvm.metadata"
define void @foo() { define void @foo() {
ret void ret void
} }

lld/test/ELF/lto/Inputs/archive-2.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @_start() { define void @_start() {
ret void ret void
} }

lld/test/ELF/lto/Inputs/archive-3.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @foo() { define void @foo() {
ret void ret void
} }

lld/test/ELF/lto/Inputs/archive.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @f() { define void @f() {
ret void ret void
} }

lld/test/ELF/lto/Inputs/asmundef.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @patatino() declare void @patatino()

lld/test/ELF/lto/Inputs/available-externally.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @zed() { define void @zed() {
ret void ret void
} }

lld/test/ELF/lto/Inputs/cache.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i32 @_start() { define i32 @_start() {
entry: entry:
call void (...) @globalfunc() call void (...) @globalfunc()
ret i32 0 ret i32 0
} }
declare void @globalfunc(...) declare void @globalfunc(...)

lld/test/ELF/lto/Inputs/common3.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@a = common hidden global i64 0, align 4 @a = common hidden global i64 0, align 4

lld/test/ELF/lto/Inputs/data-ordering-lto.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-scei-ps4" target triple = "x86_64-scei-ps4"
@pat = global i32 33, align 4 @pat = global i32 33, align 4
@tin = global i32 33, align 4 @tin = global i32 33, align 4
@dipsy = global i32 33, align 4 @dipsy = global i32 33, align 4

lld/test/ELF/lto/Inputs/defsym-bar.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @this_is_bar1() declare void @this_is_bar1()
declare void @this_is_bar2() declare void @this_is_bar2()
declare void @this_is_bar3() declare void @this_is_bar3()
define hidden void @bar1() { define hidden void @bar1() {
call void @this_is_bar1() call void @this_is_bar1()
Show All 12 Lines

lld/test/ELF/lto/Inputs/drop-linkage.ll

target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
$foo = comdat any $foo = comdat any
define linkonce void @foo() comdat { define linkonce void @foo() comdat {
ret void ret void
} }
define void @bar() { define void @bar() {
call void @foo() call void @foo()
ret void ret void
} }

lld/test/ELF/lto/Inputs/duplicated-name.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @f2() { define void @f2() {
ret void ret void
} }

lld/test/ELF/lto/Inputs/i386-empty.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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 = "i686-linux-gnu" target triple = "i686-linux-gnu"

lld/test/ELF/lto/Inputs/internalize-exportdyn.ll

target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define weak_odr void @bah() { define weak_odr void @bah() {
ret void ret void
} }

lld/test/ELF/lto/Inputs/internalize-undef.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @f() { define void @f() {
ret void ret void
} }

lld/test/ELF/lto/Inputs/irmover-error.ll

target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
!0 = !{ i32 1, !"foo", i32 2 } !0 = !{ i32 1, !"foo", i32 2 }
!llvm.module.flags = !{ !0 } !llvm.module.flags = !{ !0 }

lld/test/ELF/lto/Inputs/irmover-warning.ll

target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @f() { define void @f() {
ret void ret void
} }
!0 = !{ i32 2, !"foo", i32 2 } !0 = !{ i32 2, !"foo", i32 2 }
!llvm.module.flags = !{ !0 } !llvm.module.flags = !{ !0 }

lld/test/ELF/lto/Inputs/lazy-internal.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define hidden void @bar() { define hidden void @bar() {
ret void ret void
} }

lld/test/ELF/lto/Inputs/libcall-archive.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @memcpy() { define void @memcpy() {
ret void ret void
} }

lld/test/ELF/lto/Inputs/linker-script-symbols-ipo.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare i32 @bar() declare i32 @bar()
define i32 @_start() { define i32 @_start() {
%1 = tail call i32 @bar() %1 = tail call i32 @bar()
ret i32 %1 ret i32 %1
} }

lld/test/ELF/lto/Inputs/linkonce-odr.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define linkonce_odr void @f() { define linkonce_odr void @f() {
ret void ret void
} }

lld/test/ELF/lto/Inputs/linkonce.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define linkonce void @f() { define linkonce void @f() {
ret void ret void
} }

lld/test/ELF/lto/Inputs/obj-path.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @g() { define void @g() {
entry: entry:
ret void ret void
} }

lld/test/ELF/lto/Inputs/relocation-model-pic.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foo = external global i32 @foo = external global i32
define i32 @main() { define i32 @main() {
%t = load i32, i32* @foo %t = load i32, i32* @foo
ret i32 %t ret i32 %t
} }
!llvm.module.flags = !{!0} !llvm.module.flags = !{!0}
!0 = !{i32 1, !"PIC Level", i32 2} !0 = !{i32 1, !"PIC Level", i32 2}

lld/test/ELF/lto/Inputs/save-temps.ll

target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @bar() { define void @bar() {
ret void ret void
} }

lld/test/ELF/lto/Inputs/start-lib1.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @bar() declare void @bar()
define void @foo() { define void @foo() {
ret void ret void
} }

lld/test/ELF/lto/Inputs/start-lib2.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @bar() { define void @bar() {
ret void ret void
} }

lld/test/ELF/lto/Inputs/symbol-ordering-lto.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-scei-ps4" target triple = "x86_64-scei-ps4"
define i32 @tin() { define i32 @tin() {
ret i32 22 ret i32 22
} }
define i32 @pat() { define i32 @pat() {
ret i32 42 ret i32 42
} }

lld/test/ELF/lto/Inputs/thin1.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-scei-ps4" target triple = "x86_64-scei-ps4"
define i32 @foo(i32 %goo) { define i32 @foo(i32 %goo) {
entry: entry:
%goo.addr = alloca i32, align 4 %goo.addr = alloca i32, align 4
store i32 %goo, i32* %goo.addr, align 4 store i32 %goo, i32* %goo.addr, align 4
%0 = load i32, i32* %goo.addr, align 4 %0 = load i32, i32* %goo.addr, align 4
%1 = load i32, i32* %goo.addr, align 4 %1 = load i32, i32* %goo.addr, align 4
%mul = mul nsw i32 %0, %1 %mul = mul nsw i32 %0, %1
ret i32 %mul ret i32 %mul
} }

lld/test/ELF/lto/Inputs/thin2.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-scei-ps4" target triple = "x86_64-scei-ps4"
define i32 @blah(i32 %meh) #0 { define i32 @blah(i32 %meh) #0 {
entry: entry:
%meh.addr = alloca i32, align 4 %meh.addr = alloca i32, align 4
store i32 %meh, i32* %meh.addr, align 4 store i32 %meh, i32* %meh.addr, align 4
%0 = load i32, i32* %meh.addr, align 4 %0 = load i32, i32* %meh.addr, align 4
%sub = sub nsw i32 %0, 48 %sub = sub nsw i32 %0, 48
ret i32 %sub ret i32 %sub
} }

lld/test/ELF/lto/Inputs/thinlto.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @g() { define void @g() {
entry: entry:
ret void ret void
} }

lld/test/ELF/lto/Inputs/thinlto_empty.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"

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

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @zed() { define void @zed() {
call void @bar() call void @bar()
ret void ret void
} }
declare void @bar() declare void @bar()

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

target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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 { i16 } %zed = type { i16 }
define void @bar(%zed* %this) { define void @bar(%zed* %this) {
store %zed* %this, %zed** null store %zed* %this, %zed** null
ret void ret void
} }

lld/test/ELF/lto/Inputs/unnamed-addr-drop.ll

target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
@foo = unnamed_addr constant i32 42 @foo = unnamed_addr constant i32 42

lld/test/ELF/lto/Inputs/weakodr-visibility.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define weak_odr protected i32 @foo(i8* %this) { define weak_odr protected i32 @foo(i8* %this) {
ret i32 42 ret i32 42
} }

lld/test/ELF/lto/Inputs/wrap-bar.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define hidden void @bar() { define hidden void @bar() {
ret void ret void
} }
define hidden void @__real_bar() { define hidden void @__real_bar() {
ret void ret void
} }
define hidden void @__wrap_bar() { define hidden void @__wrap_bar() {
ret void ret void
} }

lld/test/ELF/lto/abs-resol.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: llvm-mc -triple=x86_64-pc-linux %p/Inputs/absolute.s -o %t2.o -filetype=obj ; RUN: llvm-mc -triple=x86_64-pc-linux %p/Inputs/absolute.s -o %t2.o -filetype=obj
; RUN: ld.lld %t.o %t2.o -o %t3.out -pie ; RUN: ld.lld %t.o %t2.o -o %t3.out -pie
; RUN: echo "blah = 0xdeadfeef;" > %t.script ; RUN: echo "blah = 0xdeadfeef;" > %t.script
; RUN: ld.lld %t.o -T%t.script -o %t4.out -pie ; RUN: ld.lld %t.o -T%t.script -o %t4.out -pie
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@blah = external global i8, align 1 @blah = external global i8, align 1
define i8* @_start() { define i8* @_start() {
ret i8* @blah ret i8* @blah
} }

lld/test/ELF/lto/archive-2.ll

Show All 10 Lines
; CHECK: Name: _start ( ; CHECK: Name: _start (
; CHECK-NEXT: Value: ; CHECK-NEXT: Value:
; CHECK-NEXT: Size: ; CHECK-NEXT: Size:
; CHECK-NEXT: Binding: Global ; CHECK-NEXT: Binding: Global
; CHECK-NEXT: Type: Function ; CHECK-NEXT: Type: Function
; CHECK-NEXT: Other: 0 ; CHECK-NEXT: Other: 0
; CHECK-NEXT: Section: .text ; CHECK-NEXT: Section: .text
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @g() { define void @g() {
call void @_start() call void @_start()
ret void ret void
} }
declare void @_start() declare void @_start()

lld/test/ELF/lto/archive-3.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %S/Inputs/archive-3.ll -o %t1.o ; RUN: llvm-as %S/Inputs/archive-3.ll -o %t1.o
; RUN: llvm-as %s -o %t2.o ; RUN: llvm-as %s -o %t2.o
; RUN: ld.lld %t1.o %t2.o -o %t3 -save-temps ; RUN: ld.lld %t1.o %t2.o -o %t3 -save-temps
; RUN: llvm-dis %t3.0.2.internalize.bc -o - | FileCheck %s ; RUN: llvm-dis %t3.0.2.internalize.bc -o - | FileCheck %s
; RUN: rm -f %t.a ; RUN: rm -f %t.a
; RUN: llvm-ar rcs %t.a %t1.o ; RUN: llvm-ar rcs %t.a %t1.o
; RUN: ld.lld %t.a %t1.o %t2.o -o %t3 -save-temps ; RUN: ld.lld %t.a %t1.o %t2.o -o %t3 -save-temps
; RUN: llvm-dis %t3.0.2.internalize.bc -o - | FileCheck %s ; RUN: llvm-dis %t3.0.2.internalize.bc -o - | FileCheck %s
; CHECK: define internal void @foo() { ; CHECK: define internal void @foo() {
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @_start() { define void @_start() {
ret void ret void
} }

lld/test/ELF/lto/archive-no-index.ll

; REQUIRES: x86 ; REQUIRES: x86
; Tests that we accept an archive file without symbol table ; Tests that we accept an archive file without symbol table
; if all the member files are bitcode files. ; if all the member files are bitcode files.
; RUN: llvm-as -o %t1.o %s ; RUN: llvm-as -o %t1.o %s
; RUN: llvm-as -o %t2.o %S/Inputs/archive.ll ; RUN: llvm-as -o %t2.o %S/Inputs/archive.ll
; RUN: rm -f %t1.a %t2.a ; RUN: rm -f %t1.a %t2.a
; RUN: llvm-ar crS %t1.a %t2.o ; RUN: llvm-ar crS %t1.a %t2.o
; RUN: llvm-ar crs %t2.a %t2.o ; RUN: llvm-ar crs %t2.a %t2.o
; RUN: ld.lld -o %t -emain %t1.o %t1.a ; RUN: ld.lld -o %t -emain %t1.o %t1.a
; RUN: ld.lld -o %t -emain %t1.o %t2.a ; RUN: ld.lld -o %t -emain %t1.o %t2.a
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @f() declare void @f()
define i32 @main() { define i32 @main() {
call void @f() call void @f()
ret i32 0 ret i32 0
} }
Show All 11 Lines

lld/test/ELF/lto/archive.ll

Show All 18 Lines
; CHECK: Name: f ( ; CHECK: Name: f (
; CHECK-NEXT: Value: ; CHECK-NEXT: Value:
; CHECK-NEXT: Size: ; CHECK-NEXT: Size:
; CHECK-NEXT: Binding: Global ; CHECK-NEXT: Binding: Global
; CHECK-NEXT: Type: Function ; CHECK-NEXT: Type: Function
; CHECK-NEXT: Other: 0 ; CHECK-NEXT: Other: 0
; CHECK-NEXT: Section: .text ; CHECK-NEXT: Section: .text
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @g() { define void @g() {
call void @f() call void @f()
ret void ret void
} }
declare void @f() declare void @f()

lld/test/ELF/lto/asmundef.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: llvm-as %S/Inputs/asmundef.ll -o %t2.o ; RUN: llvm-as %S/Inputs/asmundef.ll -o %t2.o
; RUN: ld.lld %t.o %t2.o -o %t -save-temps ; RUN: ld.lld %t.o %t2.o -o %t -save-temps
; RUN: llvm-dis %t.0.4.opt.bc -o - | FileCheck %s ; RUN: llvm-dis %t.0.4.opt.bc -o - | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
module asm ".weak patatino" module asm ".weak patatino"
module asm ".equ patatino, foo" module asm ".equ patatino, foo"
declare void @patatino() declare void @patatino()
define void @foo() { define void @foo() {
Show All 10 Lines

lld/test/ELF/lto/available-externally.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: llvm-as %p/Inputs/available-externally.ll -o %t2.o ; RUN: llvm-as %p/Inputs/available-externally.ll -o %t2.o
; RUN: ld.lld %t1.o %t2.o -o %t.so -shared -save-temps ; RUN: ld.lld %t1.o %t2.o -o %t.so -shared -save-temps
; RUN: llvm-dis < %t.so.0.2.internalize.bc | FileCheck %s ; RUN: llvm-dis < %t.so.0.2.internalize.bc | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @foo() { define void @foo() {
call void @bar() call void @bar()
call void @zed() call void @zed()
ret void ret void
} }
define available_externally void @bar() { define available_externally void @bar() {
ret void ret void
} }
define available_externally void @zed() { define available_externally void @zed() {
ret void ret void
} }
; CHECK: define available_externally void @bar() { ; CHECK: define available_externally void @bar() {
; CHECK: define void @zed() { ; CHECK: define void @zed() {

lld/test/ELF/lto/cache.ll

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
; RUN: touch -t 198002021200 %t.cache/llvmcache-newer ; RUN: touch -t 198002021200 %t.cache/llvmcache-newer
; RUN: ld.lld --thinlto-cache-dir=%t.cache --thinlto-cache-policy prune_after=0s:cache_size=0%:cache_size_files=3:prune_interval=0s -o %t3 %t2.o %t.o ; RUN: ld.lld --thinlto-cache-dir=%t.cache --thinlto-cache-policy prune_after=0s:cache_size=0%:cache_size_files=3:prune_interval=0s -o %t3 %t2.o %t.o
; RUN: ls %t.cache | FileCheck %s ; RUN: ls %t.cache | FileCheck %s
; CHECK-NOT: llvmcache-old ; CHECK-NOT: llvmcache-old
; CHECK: llvmcache-newer ; CHECK: llvmcache-newer
; CHECK-NOT: llvmcache-old ; CHECK-NOT: llvmcache-old
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @globalfunc() #0 { define void @globalfunc() #0 {
entry: entry:
ret void ret void
} }

lld/test/ELF/lto/codemodel.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld %t.o -o %ts -mllvm -code-model=small ; RUN: ld.lld %t.o -o %ts -mllvm -code-model=small
; RUN: ld.lld %t.o -o %tl -mllvm -code-model=large ; RUN: ld.lld %t.o -o %tl -mllvm -code-model=large
; RUN: llvm-objdump -d %ts | FileCheck %s --check-prefix=CHECK-SMALL ; RUN: llvm-objdump -d %ts | FileCheck %s --check-prefix=CHECK-SMALL
; RUN: llvm-objdump -d %tl | FileCheck %s --check-prefix=CHECK-LARGE ; RUN: llvm-objdump -d %tl | FileCheck %s --check-prefix=CHECK-LARGE
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
@data = internal constant [0 x i32] [] @data = internal constant [0 x i32] []
define i32* @_start() nounwind readonly { define i32* @_start() nounwind readonly {
entry: entry:
; CHECK-SMALL-LABEL: _start: ; CHECK-SMALL-LABEL: _start:
; CHECK-SMALL: movl $2097440, %eax ; CHECK-SMALL: movl $2097440, %eax
; CHECK-LARGE-LABEL: _start: ; CHECK-LARGE-LABEL: _start:
; CHECK-LARGE: movabsq $2097440, %rax ; CHECK-LARGE: movabsq $2097440, %rax
ret i32* getelementptr ([0 x i32], [0 x i32]* @data, i64 0, i64 0) ret i32* getelementptr ([0 x i32], [0 x i32]* @data, i64 0, i64 0)
} }

lld/test/ELF/lto/combined-lto-object-name.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: not ld.lld %t.o -o %t2 2>&1 | FileCheck %s ; RUN: not ld.lld %t.o -o %t2 2>&1 | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
declare void @foo() declare void @foo()
define void @_start() { define void @_start() {
call void @foo() call void @foo()
ret void ret void
} }
; CHECK: error: undefined symbol: foo ; CHECK: error: undefined symbol: foo
; CHECK: >>> referenced by ld-temp.o ; CHECK: >>> referenced by ld-temp.o
; CHECK: {{.*}}:(_start) ; CHECK: {{.*}}:(_start)

lld/test/ELF/lto/comdat.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld %t.o %t.o -o %t.so -shared ; RUN: ld.lld %t.o %t.o -o %t.so -shared
; RUN: llvm-readobj --symbols %t.so | FileCheck %s ; RUN: llvm-readobj --symbols %t.so | FileCheck %s
; CHECK: Name: foo ; CHECK: Name: foo
; CHECK-NEXT: Value: ; CHECK-NEXT: Value:
; CHECK-NEXT: Size: 1 ; CHECK-NEXT: Size: 1
; CHECK-NEXT: Binding: Global ; CHECK-NEXT: Binding: Global
; CHECK-NEXT: Type: Function ; CHECK-NEXT: Type: Function
; CHECK-NEXT: Other: 0 ; CHECK-NEXT: Other: 0
; CHECK-NEXT: Section: .text ; CHECK-NEXT: Section: .text
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
$foo = comdat any $foo = comdat any
define void @foo() comdat { define void @foo() comdat {
ret void ret void
} }

lld/test/ELF/lto/comdat2.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: llvm-mc -triple=x86_64-pc-linux %p/Inputs/comdat.s -o %t2.o -filetype=obj ; RUN: llvm-mc -triple=x86_64-pc-linux %p/Inputs/comdat.s -o %t2.o -filetype=obj
; RUN: ld.lld %t.o %t2.o -o %t.so -shared ; RUN: ld.lld %t.o %t2.o -o %t.so -shared
; RUN: llvm-readobj --symbols %t.so | FileCheck %s ; RUN: llvm-readobj --symbols %t.so | FileCheck %s
; RUN: ld.lld %t2.o %t.o -o %t2.so -shared ; RUN: ld.lld %t2.o %t.o -o %t2.so -shared
; RUN: llvm-readobj --symbols %t2.so | FileCheck %s --check-prefix=OTHER ; RUN: llvm-readobj --symbols %t2.so | FileCheck %s --check-prefix=OTHER
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
$c = comdat any $c = comdat any
define protected void @foo() comdat($c) { define protected void @foo() comdat($c) {
ret void ret void
} }
Show All 23 Lines

lld/test/ELF/lto/common.ll

Show All 19 Lines
; CHECK: Name: a ; CHECK: Name: a
; CHECK-NEXT: Value: ; CHECK-NEXT: Value:
; CHECK-NEXT: Size: 8 ; CHECK-NEXT: Size: 8
; CHECK-NEXT: Binding: Global ; CHECK-NEXT: Binding: Global
; CHECK-NEXT: Type: Object ; CHECK-NEXT: Type: Object
; CHECK-NEXT: Other: 0 ; CHECK-NEXT: Other: 0
; CHECK-NEXT: Section: .bss ; CHECK-NEXT: Section: .bss
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@a = common global i32 0, align 8 @a = common global i32 0, align 8

lld/test/ELF/lto/common2.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: ld.lld %t1.o -o %t -shared -save-temps ; RUN: ld.lld %t1.o -o %t -shared -save-temps
; RUN: llvm-dis < %t.0.2.internalize.bc | FileCheck %s ; RUN: llvm-dis < %t.0.2.internalize.bc | FileCheck %s
; RUN: llvm-readobj --symbols %t | FileCheck %s --check-prefix=SHARED ; RUN: llvm-readobj --symbols %t | FileCheck %s --check-prefix=SHARED
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@a = common global i8 0, align 8 @a = common global i8 0, align 8
; CHECK-DAG: @a = common global i8 0, align 8 ; CHECK-DAG: @a = common global i8 0, align 8
@b = common hidden global i32 0, align 4 @b = common hidden global i32 0, align 4
define i32 @f() { define i32 @f() {
%t = load i32, i32* @b, align 4 %t = load i32, i32* @b, align 4
Show All 13 Lines

lld/test/ELF/lto/common3.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: llvm-as %S/Inputs/common3.ll -o %t2.o ; RUN: llvm-as %S/Inputs/common3.ll -o %t2.o
; RUN: ld.lld %t1.o %t2.o -o %t -shared -save-temps ; RUN: ld.lld %t1.o %t2.o -o %t -shared -save-temps
; RUN: llvm-dis < %t.0.2.internalize.bc | FileCheck %s ; RUN: llvm-dis < %t.0.2.internalize.bc | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@a = common hidden global i32 0, align 8 @a = common hidden global i32 0, align 8
define i32 @f() { define i32 @f() {
%t = load i32, i32* @a, align 4 %t = load i32, i32* @a, align 4
ret i32 %t ret i32 %t
} }
; CHECK: @a = internal global i64 0, align 8 ; CHECK: @a = internal global i64 0, align 8

lld/test/ELF/lto/common4.ll

; REQUIRES: x86 ; REQUIRES: x86
;; Make sure that common symbols are properly internalized. ;; Make sure that common symbols are properly internalized.
;; In this file, @a does not interpose any symbol in a DSO, ;; In this file, @a does not interpose any symbol in a DSO,
;; so LTO should be able to internelize it. ;; so LTO should be able to internelize it.
; RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux /dev/null -o %t.so.o ; RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux /dev/null -o %t.so.o
; RUN: ld.lld -shared -o %t.so %t.so.o ; RUN: ld.lld -shared -o %t.so %t.so.o
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld -o %t.exe -save-temps %t.o %t.so ; RUN: ld.lld -o %t.exe -save-temps %t.o %t.so
; RUN: llvm-dis < %t.exe.0.2.internalize.bc | FileCheck %s ; RUN: llvm-dis < %t.exe.0.2.internalize.bc | FileCheck %s
; RUN: ld.lld -pie -o %t.exe -save-temps %t.o ; RUN: ld.lld -pie -o %t.exe -save-temps %t.o
; RUN: llvm-dis < %t.exe.0.2.internalize.bc | FileCheck %s ; RUN: llvm-dis < %t.exe.0.2.internalize.bc | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@a = common dso_local local_unnamed_addr global i32 0, align 4 @a = common dso_local local_unnamed_addr global i32 0, align 4
; CHECK-DAG: @a = internal global i32 0, align 4 ; CHECK-DAG: @a = internal global i32 0, align 4

lld/test/ELF/lto/cpu-string.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld %t.o -o %t.so -shared ; RUN: ld.lld %t.o -o %t.so -shared
; RUN: llvm-objdump -d -section=".text" -no-leading-addr -no-show-raw-insn %t.so | FileCheck %s ; RUN: llvm-objdump -d -section=".text" -no-leading-addr -no-show-raw-insn %t.so | FileCheck %s
; CHECK: nop{{$}} ; CHECK: nop{{$}}
; RUN: ld.lld -mllvm -mcpu=znver1 %t.o -o %t.znver1.so -shared ; RUN: ld.lld -mllvm -mcpu=znver1 %t.o -o %t.znver1.so -shared
; RUN: llvm-objdump -d -section=".text" -no-leading-addr -no-show-raw-insn %t.znver1.so | FileCheck -check-prefix=ZNVER1 %s ; RUN: llvm-objdump -d -section=".text" -no-leading-addr -no-show-raw-insn %t.znver1.so | FileCheck -check-prefix=ZNVER1 %s
; ZNVER1: nopw ; ZNVER1: nopw
; Check we are able to use -plugin-opt=mcpu=<CPU> to set CPU string. ; Check we are able to use -plugin-opt=mcpu=<CPU> to set CPU string.
; RUN: ld.lld -plugin-opt=mcpu=znver1 %t.o -o %t.znver1.so -shared ; RUN: ld.lld -plugin-opt=mcpu=znver1 %t.o -o %t.znver1.so -shared
; RUN: llvm-objdump -d -section=".text" -no-leading-addr -no-show-raw-insn %t.znver1.so | FileCheck -check-prefix=ZNVER1 %s ; RUN: llvm-objdump -d -section=".text" -no-leading-addr -no-show-raw-insn %t.znver1.so | FileCheck -check-prefix=ZNVER1 %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @foo() #0 { define void @foo() #0 {
entry: entry:
call void asm sideeffect ".p2align 4, 0x90", "~{dirflag},~{fpsr},~{flags}"() call void asm sideeffect ".p2align 4, 0x90", "~{dirflag},~{fpsr},~{flags}"()
ret void ret void
} }
attributes #0 = { "no-frame-pointer-elim"="true" } attributes #0 = { "no-frame-pointer-elim"="true" }

lld/test/ELF/lto/ctors.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld %t.o -o %t.so -shared ; RUN: ld.lld %t.o -o %t.so -shared
; RUN: llvm-readobj --sections %t.so | FileCheck %s ; RUN: llvm-readobj --sections %t.so | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" 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 }] @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @ctor, i8* null }]
define void @ctor() { define void @ctor() {
call void asm "nop", ""() call void asm "nop", ""()
ret void ret void
} }
; The llvm.global_ctors should end up producing constructors. ; The llvm.global_ctors should end up producing constructors.
; On x86-64 (linux) we should always emit .init_array and never .ctors. ; On x86-64 (linux) we should always emit .init_array and never .ctors.
; CHECK: Name: .init_array ; CHECK: Name: .init_array
; CHECK-NOT: Name: .ctors ; CHECK-NOT: Name: .ctors

lld/test/ELF/lto/debugger-tune.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; Here we verify that -debugger-tune=<value> option is ; Here we verify that -debugger-tune=<value> option is
; handled by LLD. DWARF linkage name attributes are optional, ; handled by LLD. DWARF linkage name attributes are optional,
; they normally present, but are missing for SCE debugger tune. ; they normally present, but are missing for SCE debugger tune.
; RUN: ld.lld %t.o -o %t.exe ; RUN: ld.lld %t.o -o %t.exe
; RUN: llvm-dwarfdump %t.exe | FileCheck %s ; RUN: llvm-dwarfdump %t.exe | FileCheck %s
; CHECK: DW_AT_linkage_name ("name_of_foo") ; CHECK: DW_AT_linkage_name ("name_of_foo")
; RUN: ld.lld -plugin-opt=-debugger-tune=sce %t.o -o %t.exe ; RUN: ld.lld -plugin-opt=-debugger-tune=sce %t.o -o %t.exe
; RUN: llvm-dwarfdump %t.exe | FileCheck --check-prefix=SCE %s ; RUN: llvm-dwarfdump %t.exe | FileCheck --check-prefix=SCE %s
; SCE-NOT: name_of_foo ; SCE-NOT: name_of_foo
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foo = global i32 0, align 4, !dbg !0 @foo = global i32 0, align 4, !dbg !0
!llvm.dbg.cu = !{!5} !llvm.dbg.cu = !{!5}
!llvm.module.flags = !{!8, !9} !llvm.module.flags = !{!8, !9}
!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression()) !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
Show All 11 Lines

lld/test/ELF/lto/defsym.ll

Show All 19 Lines
; CHECK: foo: ; CHECK: foo:
; CHECK-NEXT: pushq %rax ; CHECK-NEXT: pushq %rax
; CHECK-NEXT: callq ; CHECK-NEXT: callq
; CHECK-NEXT: callq{{.*}}<bar3> ; CHECK-NEXT: callq{{.*}}<bar3>
; CHECK-NEXT: popq %rax ; CHECK-NEXT: popq %rax
; CHECK-NEXT: jmp ; CHECK-NEXT: jmp
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @bar1() declare void @bar1()
declare void @bar2() declare void @bar2()
declare void @bar3() declare void @bar3()
define void @foo() { define void @foo() {
call void @bar1() call void @bar1()
call void @bar2() call void @bar2()
call void @bar3() call void @bar3()
ret void ret void
} }

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

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

lld/test/ELF/lto/drop-linkage.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llc %s -o %t.o -filetype=obj ; RUN: llc %s -o %t.o -filetype=obj
; RUN: llvm-as %p/Inputs/drop-linkage.ll -o %t2.o ; RUN: llvm-as %p/Inputs/drop-linkage.ll -o %t2.o
; RUN: ld.lld %t.o %t2.o -o %t.so -save-temps -shared ; RUN: ld.lld %t.o %t2.o -o %t.so -save-temps -shared
; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s ; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @foo() { define void @foo() {
ret void ret void
} }
; CHECK: declare void @foo() ; CHECK: declare void @foo()

lld/test/ELF/lto/duplicated-name.ll

; REQUIRES: x86 ; REQUIRES: x86
; Cretae two archive with the same member name ; Cretae two archive with the same member name
; RUN: rm -f %t1.a %t2.a ; RUN: rm -f %t1.a %t2.a
; RUN: opt -module-summary %s -o %t.o ; RUN: opt -module-summary %s -o %t.o
; RUN: llvm-ar rcS %t1.a %t.o ; RUN: llvm-ar rcS %t1.a %t.o
; RUN: opt -module-summary %p/Inputs/duplicated-name.ll -o %t.o ; RUN: opt -module-summary %p/Inputs/duplicated-name.ll -o %t.o
; RUN: llvm-ar rcS %t2.a %t.o ; RUN: llvm-ar rcS %t2.a %t.o
; RUN: ld.lld -m elf_x86_64 -shared -o %t.so -uf1 -uf2 %t1.a %t2.a ; RUN: ld.lld -m elf_x86_64 -shared -o %t.so -uf1 -uf2 %t1.a %t2.a
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @f1() { define void @f1() {
ret void ret void
} }

lld/test/ELF/lto/duplicated.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: not ld.lld %t.o %t.o -o %t.so -shared 2>&1 | FileCheck %s ; RUN: not ld.lld %t.o %t.o -o %t.so -shared 2>&1 | FileCheck %s
; CHECK: duplicate symbol: f ; CHECK: duplicate symbol: f
; CHECK-NEXT: >>> defined in {{.*}}.o ; CHECK-NEXT: >>> defined in {{.*}}.o
; CHECK-NEXT: >>> defined in {{.*}}.o ; CHECK-NEXT: >>> defined in {{.*}}.o
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @f() { define void @f() {
ret void ret void
} }

lld/test/ELF/lto/dynamic-list.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: echo "{ foo; };" > %t.list ; RUN: echo "{ foo; };" > %t.list
; RUN: ld.lld -o %t --dynamic-list %t.list -pie %t.o ; RUN: ld.lld -o %t --dynamic-list %t.list -pie %t.o
; RUN: llvm-readobj --dyn-syms %t | FileCheck %s ; RUN: llvm-readobj --dyn-syms %t | FileCheck %s
; CHECK: Name: foo ; CHECK: Name: foo
; CHECK-NEXT: Value: 0x1010 ; CHECK-NEXT: Value: 0x1010
; CHECK-NEXT: Size: 1 ; CHECK-NEXT: Size: 1
; CHECK-NEXT: Binding: Global (0x1) ; CHECK-NEXT: Binding: Global (0x1)
; CHECK-NEXT: Type: Function ; CHECK-NEXT: Type: Function
; CHECK-NEXT: Other: 0 ; CHECK-NEXT: Other: 0
; CHECK-NEXT: Section: .text ; CHECK-NEXT: Section: .text
; CHECK-NEXT: } ; CHECK-NEXT: }
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @_start() { define void @_start() {
ret void ret void
} }
define void @foo() { define void @foo() {
ret void ret void
} }

lld/test/ELF/lto/dynsym.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux -o %t.o %p/Inputs/dynsym.s ; RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux -o %t.o %p/Inputs/dynsym.s
; RUN: ld.lld %t.o -o %t.so -shared ; RUN: ld.lld %t.o -o %t.so -shared
; RUN: llvm-as %s -o %t2.o ; RUN: llvm-as %s -o %t2.o
; RUN: ld.lld %t2.o %t.so -o %t ; RUN: ld.lld %t2.o %t.so -o %t
; RUN: llvm-readobj --dyn-syms %t | FileCheck %s ; RUN: llvm-readobj --dyn-syms %t | FileCheck %s
; Check that we don't crash when gc'ing sections and printing the result. ; Check that we don't crash when gc'ing sections and printing the result.
; RUN: ld.lld %t2.o %t.so --gc-sections --print-gc-sections \ ; RUN: ld.lld %t2.o %t.so --gc-sections --print-gc-sections \
; RUN: -o %t ; RUN: -o %t
; RUN: llvm-readobj --dyn-syms %t | FileCheck %s ; RUN: llvm-readobj --dyn-syms %t | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @_start() { define void @_start() {
call void @foo() call void @foo()
ret void ret void
} }
; CHECK: Name: foo ; CHECK: Name: foo
Show All 9 Lines

lld/test/ELF/lto/emit-llvm.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: opt -module-hash -module-summary %s -o %t.o ; RUN: opt -module-hash -module-summary %s -o %t.o
; RUN: ld.lld --plugin-opt=emit-llvm -o %t.out.o %t.o ; RUN: ld.lld --plugin-opt=emit-llvm -o %t.out.o %t.o
; RUN: llvm-dis < %t.out.o -o - | FileCheck %s ; RUN: llvm-dis < %t.out.o -o - | FileCheck %s
; CHECK: define internal void @main() ; CHECK: define internal void @main()
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @main() { define void @main() {
ret void ret void
} }

lld/test/ELF/lto/inline-asm.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld %t.o -o %t.so -shared ; RUN: ld.lld %t.o -o %t.so -shared
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @foo() { define void @foo() {
call void asm "nop", ""() call void asm "nop", ""()
ret void ret void
} }

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

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld %t.o -o %t2 -save-temps ; RUN: ld.lld %t.o -o %t2 -save-temps
; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s ; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @_start() { define void @_start() {
ret void ret void
} }
define hidden void @foo() { define hidden void @foo() {
ret void ret void
} }
; Check that _start is not internalized. ; Check that _start is not internalized.
; CHECK: define dso_local void @_start() ; CHECK: define dso_local void @_start()
; Check that foo function is correctly internalized. ; Check that foo function is correctly internalized.
; CHECK: define internal void @foo() ; CHECK: define internal void @foo()

lld/test/ELF/lto/internalize-exportdyn.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: llvm-as %p/Inputs/internalize-exportdyn.ll -o %t2.o ; RUN: llvm-as %p/Inputs/internalize-exportdyn.ll -o %t2.o
; RUN: ld.lld %t.o %t2.o -o %t2 --export-dynamic -save-temps ; RUN: ld.lld %t.o %t2.o -o %t2 --export-dynamic -save-temps
; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s ; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @_start() { define void @_start() {
ret void ret void
} }
define void @foo() { define void @foo() {
ret void ret void
} }
Show All 31 Lines

lld/test/ELF/lto/internalize-llvmused.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld %t.o -o %t2 -save-temps ; RUN: ld.lld %t.o -o %t2 -save-temps
; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s ; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @_start() { define void @_start() {
ret void ret void
} }
define hidden void @f() { define hidden void @f() {
ret void ret void
} }
@llvm.used = appending global [1 x i8*] [ i8* bitcast (void ()* @f to i8*)] @llvm.used = appending global [1 x i8*] [ i8* bitcast (void ()* @f to i8*)]
; Check that f is not internalized. ; Check that f is not internalized.
; CHECK: define hidden void @f() ; CHECK: define hidden void @f()

lld/test/ELF/lto/internalize-undef.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: llvm-as %p/Inputs/internalize-undef.ll -o %t2.o ; RUN: llvm-as %p/Inputs/internalize-undef.ll -o %t2.o
; RUN: ld.lld %t.o %t2.o -o %t -save-temps ; RUN: ld.lld %t.o %t2.o -o %t -save-temps
; RUN: llvm-dis < %t.0.2.internalize.bc | FileCheck %s ; RUN: llvm-dis < %t.0.2.internalize.bc | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @f() declare void @f()
define void @_start() { define void @_start() {
call void @f() call void @f()
ret void ret void
} }
; CHECK: define internal void @f() ; CHECK: define internal void @f()

lld/test/ELF/lto/internalize-version-script.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: echo "{ global: foo; local: *; };" > %t.script ; RUN: echo "{ global: foo; local: *; };" > %t.script
; RUN: ld.lld %t.o -o %t2 -shared --version-script %t.script -save-temps ; RUN: ld.lld %t.o -o %t2 -shared --version-script %t.script -save-temps
; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s ; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @foo() { define void @foo() {
ret void ret void
} }
define void @bar() { define void @bar() {
ret void ret void
} }
; Check that foo is not internalized. ; Check that foo is not internalized.
; CHECK: define void @foo() ; CHECK: define void @foo()
; Check that bar is correctly internalized. ; Check that bar is correctly internalized.
; CHECK: define internal void @bar() ; CHECK: define internal void @bar()

lld/test/ELF/lto/irmover-error.ll

; RUN: llvm-as -o %t1.bc %s ; RUN: llvm-as -o %t1.bc %s
; RUN: llvm-as -o %t2.bc %S/Inputs/irmover-error.ll ; RUN: llvm-as -o %t2.bc %S/Inputs/irmover-error.ll
; RUN: not ld.lld %t1.bc %t2.bc -o %t 2>&1 | FileCheck %s ; RUN: not ld.lld %t1.bc %t2.bc -o %t 2>&1 | FileCheck %s
; CHECK: linking module flags 'foo': IDs have conflicting values ; CHECK: linking module flags 'foo': IDs have conflicting values
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
!0 = !{ i32 1, !"foo", i32 1 } !0 = !{ i32 1, !"foo", i32 1 }
!llvm.module.flags = !{ !0 } !llvm.module.flags = !{ !0 }

lld/test/ELF/lto/irmover-warning.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as -o %t1.bc %s ; RUN: llvm-as -o %t1.bc %s
; RUN: llvm-as -o %t2.bc %S/Inputs/irmover-warning.ll ; RUN: llvm-as -o %t2.bc %S/Inputs/irmover-warning.ll
; RUN: rm -f %t.a ; RUN: rm -f %t.a
; RUN: llvm-ar rcs %t.a %t2.bc ; RUN: llvm-ar rcs %t.a %t2.bc
; RUN: ld.lld %t1.bc %t.a -o %t 2>&1 | FileCheck %s ; RUN: ld.lld %t1.bc %t.a -o %t 2>&1 | FileCheck %s
; CHECK: warning: linking module flags 'foo': IDs have conflicting values ; CHECK: warning: linking module flags 'foo': IDs have conflicting values
; CHECK-SAME: irmover-warning.ll.tmp.a(irmover-warning.ll.tmp2.bc at {{[0-9]+}}) ; CHECK-SAME: irmover-warning.ll.tmp.a(irmover-warning.ll.tmp2.bc at {{[0-9]+}})
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
declare void @f() declare void @f()
define void @g() { define void @g() {
call void @f() call void @f()
ret void ret void
} }
!0 = !{ i32 2, !"foo", i32 1 } !0 = !{ i32 2, !"foo", i32 1 }
!llvm.module.flags = !{ !0 } !llvm.module.flags = !{ !0 }

lld/test/ELF/lto/keep-undefined.ll

; REQUIRES: x86 ; REQUIRES: x86
; This test checks that symbols which are specified in "-u" switches ; This test checks that symbols which are specified in "-u" switches
; are kept over LTO if we link an executable. ; are kept over LTO if we link an executable.
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld %t.o -o %tout -u foo ; RUN: ld.lld %t.o -o %tout -u foo
; RUN: llvm-nm %tout | FileCheck %s ; RUN: llvm-nm %tout | FileCheck %s
; CHECK: T foo ; CHECK: T foo
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @foo() { define void @foo() {
ret void ret void
} }
define void @_start() { define void @_start() {
call void @foo() call void @foo()
ret void ret void
} }

lld/test/ELF/lto/lazy-internal.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: llvm-as %p/Inputs/lazy-internal.ll -o %t2.o ; RUN: llvm-as %p/Inputs/lazy-internal.ll -o %t2.o
; RUN: rm -f %t2.a ; RUN: rm -f %t2.a
; RUN: llvm-ar rc %t2.a %t2.o ; RUN: llvm-ar rc %t2.a %t2.o
; RUN: ld.lld %t2.a %t1.o -o %t.so -shared -save-temps ; RUN: ld.lld %t2.a %t1.o -o %t.so -shared -save-temps
; RUN: llvm-dis %t.so.0.2.internalize.bc -o - | FileCheck %s ; RUN: llvm-dis %t.so.0.2.internalize.bc -o - | FileCheck %s
; CHECK: define internal void @foo() ; CHECK: define internal void @foo()
; CHECK: define internal void @bar() ; CHECK: define internal void @bar()
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define hidden void @foo() { define hidden void @foo() {
call void @bar() call void @bar()
ret void ret void
} }
declare void @bar() declare void @bar()

lld/test/ELF/lto/libcall-archive.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: rm -f %t.a ; RUN: rm -f %t.a
; RUN: llvm-as -o %t.o %s ; RUN: llvm-as -o %t.o %s
; RUN: llvm-as -o %t2.o %S/Inputs/libcall-archive.ll ; RUN: llvm-as -o %t2.o %S/Inputs/libcall-archive.ll
; RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux -o %t3.o %S/Inputs/libcall-archive.s ; RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux -o %t3.o %S/Inputs/libcall-archive.s
; RUN: llvm-ar rcs %t.a %t2.o %t3.o ; RUN: llvm-ar rcs %t.a %t2.o %t3.o
; RUN: ld.lld -o %t %t.o %t.a ; RUN: ld.lld -o %t %t.o %t.a
; RUN: llvm-nm %t | FileCheck %s ; RUN: llvm-nm %t | FileCheck %s
; RUN: ld.lld -o %t2 %t.o --start-lib %t2.o %t3.o --end-lib ; RUN: ld.lld -o %t2 %t.o --start-lib %t2.o %t3.o --end-lib
; RUN: llvm-nm %t2 | FileCheck %s ; RUN: llvm-nm %t2 | FileCheck %s
; CHECK-NOT: T __sync_val_compare_and_swap_8 ; CHECK-NOT: T __sync_val_compare_and_swap_8
; CHECK: T _start ; CHECK: T _start
; CHECK: T memcpy ; CHECK: T memcpy
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @_start(i8* %a, i8* %b) { define void @_start(i8* %a, i8* %b) {
entry: entry:
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 1024, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 1024, i1 false)
ret void ret void
} }
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1)

lld/test/ELF/lto/linkage.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: ld.lld %t1.o %t1.o -o %t.so -shared ; RUN: ld.lld %t1.o %t1.o -o %t.so -shared
; RUN: llvm-nm %t.so | FileCheck %s ; RUN: llvm-nm %t.so | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; Should not encounter a duplicate symbol error for @.str ; Should not encounter a duplicate symbol error for @.str
@.str = private unnamed_addr constant [4 x i8] c"Hey\00", align 1 @.str = private unnamed_addr constant [4 x i8] c"Hey\00", align 1
; Should not encounter a duplicate symbol error for @llvm.global_ctors ; Should not encounter a duplicate symbol error for @llvm.global_ctors
@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @ctor, i8* null }] @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @ctor, i8* null }]
define internal void @ctor() { define internal void @ctor() {
ret void ret void
} }
; Should not try to merge a declaration into the combined module. ; Should not try to merge a declaration into the combined module.
declare i32 @llvm.ctpop.i32(i32) declare i32 @llvm.ctpop.i32(i32)
; CHECK-NOT: llvm.ctpop.i32 ; CHECK-NOT: llvm.ctpop.i32

lld/test/ELF/lto/linker-script-symbols-assign.ll

Show All 27 Lines
; ABS-NEXT: Size: 0 ; ABS-NEXT: Size: 0
; ABS-NEXT: Binding: Global ; ABS-NEXT: Binding: Global
; ABS-NEXT: Type: None ; ABS-NEXT: Type: None
; ABS-NEXT: Other: 0 ; ABS-NEXT: Other: 0
; ABS-NEXT: Section: Absolute ; ABS-NEXT: Section: Absolute
; ABS-NEXT: } ; ABS-NEXT: }
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
@foo = global i32 0 @foo = global i32 0
@bar = global i32 0 @bar = global i32 0

lld/test/ELF/lto/linker-script-symbols-ipo.ll

Show All 14 Lines
; RUN: ld.lld %t1.o %t2.o -o %t4 --script %t.script -save-temps ; RUN: ld.lld %t1.o %t2.o -o %t4 --script %t.script -save-temps
; RUN: llvm-objdump -d %t4 | FileCheck %s --check-prefix=NOIPO ; RUN: llvm-objdump -d %t4 | FileCheck %s --check-prefix=NOIPO
; NOIPO: Disassembly of section .text: ; NOIPO: Disassembly of section .text:
; NOIPO: foo: ; NOIPO: foo:
; NOIPO-NEXT: {{.*}} movl $2, %eax ; NOIPO-NEXT: {{.*}} movl $2, %eax
; NOIPO: _start: ; NOIPO: _start:
; NOIPO-NEXT: {{.*}} jmp -21 <foo> ; NOIPO-NEXT: {{.*}} jmp -21 <foo>
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i32 @bar() { define i32 @bar() {
ret i32 1 ret i32 1
} }
define i32 @foo() { define i32 @foo() {
ret i32 2 ret i32 2
} }

lld/test/ELF/lto/linker-script-symbols.ll

Show All 13 Lines
; CHECK-NEXT: Binding: Global ; CHECK-NEXT: Binding: Global
; CHECK-NEXT: Type: Function ; CHECK-NEXT: Type: Function
; CHECK-NEXT: Other: ; CHECK-NEXT: Other:
; CHECK-NEXT: Section: ; CHECK-NEXT: Section:
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NOT: zed ; CHECK-NOT: zed
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @bar() { define void @bar() {
ret void ret void
} }
define void @zed() { define void @zed() {
ret void ret void
} }

lld/test/ELF/lto/linkonce-odr.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %p/Inputs/linkonce-odr.ll -o %t1.o ; RUN: llvm-as %p/Inputs/linkonce-odr.ll -o %t1.o
; RUN: llc -relocation-model=pic %s -o %t2.o -filetype=obj ; RUN: llc -relocation-model=pic %s -o %t2.o -filetype=obj
; RUN: ld.lld %t1.o %t2.o -o %t.so -shared -save-temps ; RUN: ld.lld %t1.o %t2.o -o %t.so -shared -save-temps
; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s ; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @f() declare void @f()
define void @g() { define void @g() {
call void @f() call void @f()
ret void ret void
} }
; Be sure that 'f' is kept and has weak_odr linkage. ; Be sure that 'f' is kept and has weak_odr linkage.
; CHECK: define weak_odr void @f() ; CHECK: define weak_odr void @f()

lld/test/ELF/lto/linkonce.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %p/Inputs/linkonce.ll -o %t1.o ; RUN: llvm-as %p/Inputs/linkonce.ll -o %t1.o
; RUN: llc -relocation-model=pic %s -o %t2.o -filetype=obj ; RUN: llc -relocation-model=pic %s -o %t2.o -filetype=obj
; RUN: ld.lld %t1.o %t2.o -o %t.so -shared -save-temps ; RUN: ld.lld %t1.o %t2.o -o %t.so -shared -save-temps
; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s ; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @f() declare void @f()
define void @g() { define void @g() {
call void @f() call void @f()
ret void ret void
} }
; Be sure that 'f' is kept and has weak linkage. ; Be sure that 'f' is kept and has weak linkage.
; CHECK: define weak void @f() ; CHECK: define weak void @f()

lld/test/ELF/lto/lto-start.ll

Show All 10 Lines
; CHECK-NEXT: Value: ; CHECK-NEXT: Value:
; CHECK-NEXT: Size: 1 ; CHECK-NEXT: Size: 1
; CHECK-NEXT: Binding: Global ; CHECK-NEXT: Binding: Global
; CHECK-NEXT: Type: Function ; CHECK-NEXT: Type: Function
; CHECK-NEXT: Other: ; CHECK-NEXT: Other:
; CHECK-NEXT: Section: .text ; CHECK-NEXT: Section: .text
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @_start() { define void @_start() {
ret void ret void
} }

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

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; 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: 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 ; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" 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 }] @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @ctor, i8* null }]
define void @ctor() { define void @ctor() {
ret void ret void
} }
; `@ctor` doesn't do anything and so the optimizer should kill it, leaving no ctors ; `@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, void ()*, i8* }] zeroinitializer
; MLLVM: Pass Arguments: ; MLLVM: Pass Arguments:

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

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld %t.o -o %t.so -save-temps --lto-aa-pipeline=basic-aa \ ; RUN: ld.lld %t.o -o %t.so -save-temps --lto-aa-pipeline=basic-aa \
; RUN: --lto-newpm-passes=ipsccp -shared ; RUN: --lto-newpm-passes=ipsccp -shared
; RUN: ld.lld %t.o -o %t2.so -save-temps --lto-newpm-passes=loweratomic -shared ; RUN: ld.lld %t.o -o %t2.so -save-temps --lto-newpm-passes=loweratomic -shared
; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s ; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s
; RUN: llvm-dis %t2.so.0.4.opt.bc -o - | FileCheck %s --check-prefix=ATOMIC ; RUN: llvm-dis %t2.so.0.4.opt.bc -o - | FileCheck %s --check-prefix=ATOMIC
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @barrier() { define void @barrier() {
fence seq_cst fence seq_cst
ret void ret void
} }
; IPSCCP won't remove the fence. ; IPSCCP won't remove the fence.
Show All 20 Lines

lld/test/ELF/lto/metadata.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: ld.lld %t1.o %t1.o -o %t.so -shared ; RUN: ld.lld %t1.o %t1.o -o %t.so -shared
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define weak void @foo(i32* %p) { define weak void @foo(i32* %p) {
store i32 5, i32* %p, align 4, !tbaa !0 store i32 5, i32* %p, align 4, !tbaa !0
ret void ret void
} }
!0 = !{!1, !1, i64 0} !0 = !{!1, !1, i64 0}
!1 = !{!"int", !2} !1 = !{!"int", !2}
!2 = !{!"Simple C/C++ TBAA"} !2 = !{!"Simple C/C++ TBAA"}

lld/test/ELF/lto/mix-platforms.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-mc %p/Inputs/shared.s -o %t386.o -filetype=obj -triple=i386-pc-linux ; RUN: llvm-mc %p/Inputs/shared.s -o %t386.o -filetype=obj -triple=i386-pc-linux
; RUN: ld.lld %t386.o -o %ti386.so -shared ; RUN: ld.lld %t386.o -o %ti386.so -shared
; RUN: llvm-as %s -o %tx64.o ; RUN: llvm-as %s -o %tx64.o
; RUN: not ld.lld %ti386.so %tx64.o -o %t 2>&1 | FileCheck %s ; RUN: not ld.lld %ti386.so %tx64.o -o %t 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; CHECK: {{.*}}x64.o is incompatible with {{.*}}i386.so ; CHECK: {{.*}}x64.o is incompatible with {{.*}}i386.so

lld/test/ELF/lto/mix-platforms2.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %tx64.o ; RUN: llvm-as %s -o %tx64.o
; RUN: llvm-as %S/Inputs/i386-empty.ll -o %ti386.o ; RUN: llvm-as %S/Inputs/i386-empty.ll -o %ti386.o
; RUN: not ld.lld %ti386.o %tx64.o -o %t.out 2>&1 | FileCheck %s ; RUN: not ld.lld %ti386.o %tx64.o -o %t.out 2>&1 | FileCheck %s
; CHECK: {{.*}}x64.o is incompatible with {{.*}}i386.o ; CHECK: {{.*}}x64.o is incompatible with {{.*}}i386.o
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"

lld/test/ELF/lto/module-asm.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld %t.o -o %t ; RUN: ld.lld %t.o -o %t
; RUN: llvm-nm %t | FileCheck %s ; RUN: llvm-nm %t | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
module asm ".text" module asm ".text"
module asm ".globl foo" module asm ".globl foo"
; CHECK: T foo ; CHECK: T foo
module asm "foo: ret" module asm "foo: ret"
declare void @foo() declare void @foo()
define void @_start() { define void @_start() {
call void @foo() call void @foo()
ret void ret void
} }

lld/test/ELF/lto/new-pass-manager.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: opt -module-summary %s -o %t.o ; RUN: opt -module-summary %s -o %t.o
; Test new-pass-manager and debug-pass-manager option ; Test new-pass-manager and debug-pass-manager option
; RUN: ld.lld --plugin-opt=new-pass-manager --plugin-opt=debug-pass-manager -o %t2.o %t.o 2>&1 | FileCheck %s ; RUN: ld.lld --plugin-opt=new-pass-manager --plugin-opt=debug-pass-manager -o %t2.o %t.o 2>&1 | FileCheck %s
; RUN: ld.lld --plugin-opt=new-pass-manager --lto-debug-pass-manager -o %t2.o %t.o 2>&1 | FileCheck %s ; RUN: ld.lld --plugin-opt=new-pass-manager --lto-debug-pass-manager -o %t2.o %t.o 2>&1 | FileCheck %s
; RUN: ld.lld --lto-new-pass-manager --plugin-opt=debug-pass-manager -o %t2.o %t.o 2>&1 | FileCheck %s ; RUN: ld.lld --lto-new-pass-manager --plugin-opt=debug-pass-manager -o %t2.o %t.o 2>&1 | FileCheck %s
; RUN: ld.lld --lto-new-pass-manager --lto-debug-pass-manager -o %t2.o %t.o 2>&1 | FileCheck %s ; RUN: ld.lld --lto-new-pass-manager --lto-debug-pass-manager -o %t2.o %t.o 2>&1 | FileCheck %s
; CHECK: Starting llvm::Module pass manager run ; CHECK: Starting llvm::Module pass manager run
; CHECK: Finished llvm::Module pass manager run ; CHECK: Finished llvm::Module pass manager run
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"

lld/test/ELF/lto/obj-path.ll

Show All 17 Lines
; CHECK-NEXT: Value: 0x1000 ; CHECK-NEXT: Value: 0x1000
; NM1: T f ; NM1: T f
; ELF1: Format: ELF64-x86-64 ; ELF1: Format: ELF64-x86-64
; NM2: T g ; NM2: T g
; ELF2: Format: ELF64-x86-64 ; ELF2: Format: ELF64-x86-64
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @g(...) declare void @g(...)
define void @f() { define void @f() {
entry: entry:
call void (...) @g() call void (...) @g()
ret void ret void
} }

lld/test/ELF/lto/opt-level.ll

Show All 22 Lines
; RUN: not ld.lld -o %t3 -e main --lto-O-1 %t.o 2>&1 | \ ; RUN: not ld.lld -o %t3 -e main --lto-O-1 %t.o 2>&1 | \
; RUN: FileCheck --check-prefix=INVALIDNEGATIVE1 %s ; RUN: FileCheck --check-prefix=INVALIDNEGATIVE1 %s
; INVALIDNEGATIVE1: invalid optimization level for LTO: 4294967295 ; INVALIDNEGATIVE1: invalid optimization level for LTO: 4294967295
; RUN: not ld.lld -o %t3 -e main --plugin-opt=O-1 %t.o 2>&1 | \ ; RUN: not ld.lld -o %t3 -e main --plugin-opt=O-1 %t.o 2>&1 | \
; RUN: FileCheck --check-prefix=INVALIDNEGATIVE2 %s ; RUN: FileCheck --check-prefix=INVALIDNEGATIVE2 %s
; INVALIDNEGATIVE2: invalid optimization level for LTO: 4294967295 ; INVALIDNEGATIVE2: invalid optimization level for LTO: 4294967295
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; CHECK-O0: foo ; CHECK-O0: foo
; CHECK-O2-NOT: foo ; CHECK-O2-NOT: foo
define internal void @foo() { define internal void @foo() {
ret void ret void
} }
define void @main() { define void @main() {
call void @foo() call void @foo()
ret void ret void
} }

lld/test/ELF/lto/opt-remarks.ll

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
; YAML-HOT-NEXT: - Cost: '0' ; YAML-HOT-NEXT: - Cost: '0'
; YAML-HOT-NEXT: - String: ', threshold=' ; YAML-HOT-NEXT: - String: ', threshold='
; YAML-HOT-NEXT: - Threshold: '337' ; YAML-HOT-NEXT: - Threshold: '337'
; YAML-HOT-NEXT: - String: ')' ; YAML-HOT-NEXT: - String: ')'
; YAML-HOT-NEXT: ... ; YAML-HOT-NEXT: ...
; YAML-PASSES: Pass: inline ; YAML-PASSES: Pass: inline
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-scei-ps4" target triple = "x86_64-scei-ps4"
declare i32 @patatino() declare i32 @patatino()
define i32 @tinkywinky() { define i32 @tinkywinky() {
%a = call i32 @patatino() %a = call i32 @patatino()
ret i32 %a ret i32 %a
} }
define i32 @main() !prof !0 { define i32 @main() !prof !0 {
%i = call i32 @tinkywinky() %i = call i32 @tinkywinky()
ret i32 %i ret i32 %i
} }
!0 = !{!"function_entry_count", i64 300} !0 = !{!"function_entry_count", i64 300}

lld/test/ELF/lto/parallel-internalize.ll

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
; CHECK-NEXT: Type: Function (0x2) ; CHECK-NEXT: Type: Function (0x2)
; CHECK-NEXT: Other: 0 ; CHECK-NEXT: Other: 0
; CHECK-NEXT: Section: .text (0x2) ; CHECK-NEXT: Section: .text (0x2)
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: ] ; CHECK-NEXT: ]
; CHECK-NEXT: DynamicSymbols [ ; CHECK-NEXT: DynamicSymbols [
; CHECK-NEXT: ] ; CHECK-NEXT: ]
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; CHECK0: U bar ; CHECK0: U bar
; CHECK0: T foo ; CHECK0: T foo
define void @foo() { define void @foo() {
call void @bar() call void @bar()
ret void ret void
} }
; CHECK1: T bar ; CHECK1: T bar
; CHECK1: U foo ; CHECK1: U foo
define void @bar() { define void @bar() {
call void @foo() call void @foo()
ret void ret void
} }

lld/test/ELF/lto/parallel.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as -o %t.bc %s ; RUN: llvm-as -o %t.bc %s
; RUN: rm -f %t.lto.o %t1.lto.o ; RUN: rm -f %t.lto.o %t1.lto.o
; RUN: ld.lld --lto-partitions=2 -save-temps -o %t %t.bc -shared ; RUN: ld.lld --lto-partitions=2 -save-temps -o %t %t.bc -shared
; RUN: llvm-nm %t.lto.o | FileCheck --check-prefix=CHECK0 %s ; RUN: llvm-nm %t.lto.o | FileCheck --check-prefix=CHECK0 %s
; RUN: llvm-nm %t1.lto.o | FileCheck --check-prefix=CHECK1 %s ; RUN: llvm-nm %t1.lto.o | FileCheck --check-prefix=CHECK1 %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; CHECK0-NOT: bar ; CHECK0-NOT: bar
; CHECK0: T foo ; CHECK0: T foo
; CHECK0-NOT: bar ; CHECK0-NOT: bar
define void @foo() { define void @foo() {
call void @bar() call void @bar()
ret void ret void
Show All 9 Lines

lld/test/ELF/lto/pic.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld %t.o -o %t.so -shared ; RUN: ld.lld %t.o -o %t.so -shared
; RUN: llvm-readobj -r %t.so | FileCheck %s ; RUN: llvm-readobj -r %t.so | FileCheck %s
; CHECK: Relocations [ ; CHECK: Relocations [
; CHECK-NEXT: Section ({{.*}}) .rela.plt { ; CHECK-NEXT: Section ({{.*}}) .rela.plt {
; CHECK-NEXT: R_X86_64_JUMP_SLOT bar 0x0 ; CHECK-NEXT: R_X86_64_JUMP_SLOT bar 0x0
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: ] ; CHECK-NEXT: ]
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @bar() declare void @bar()
define void @foo() { define void @foo() {
call void @bar() call void @bar()
ret void ret void
} }

lld/test/ELF/lto/relax-relocs.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld -save-temps -shared %t.o -o %t.so ; RUN: ld.lld -save-temps -shared %t.o -o %t.so
; RUN: llvm-readobj -r %t.so.lto.o | FileCheck %s ; RUN: llvm-readobj -r %t.so.lto.o | FileCheck %s
; Test that we produce R_X86_64_REX_GOTPCRELX instead of R_X86_64_GOTPCREL ; Test that we produce R_X86_64_REX_GOTPCRELX instead of R_X86_64_GOTPCREL
; CHECK: R_X86_64_REX_GOTPCRELX foo ; CHECK: R_X86_64_REX_GOTPCRELX foo
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foo = external global i32 @foo = external global i32
define i32 @bar() { define i32 @bar() {
%t = load i32, i32* @foo %t = load i32, i32* @foo
ret i32 %t ret i32 %t
} }

lld/test/ELF/lto/relocatable.ll

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
; CHECK-NEXT: Size: 1 ; CHECK-NEXT: Size: 1
; CHECK-NEXT: Binding: Global ; CHECK-NEXT: Binding: Global
; CHECK-NEXT: Type: Function ; CHECK-NEXT: Type: Function
; CHECK-NEXT: Other: 0 ; CHECK-NEXT: Other: 0
; CHECK-NEXT: Section: .text.foo ; CHECK-NEXT: Section: .text.foo
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: ] ; CHECK-NEXT: ]
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @foo() { define void @foo() {
call void @bar() call void @bar()
ret void ret void
} }
define internal void @bar() { define internal void @bar() {
ret void ret void
} }
declare i32 @baz(...) declare i32 @baz(...)

lld/test/ELF/lto/relocation-model.ll

Show All 39 Lines
; RUN: ld.lld %t.o -o %t-out -save-temps -r -mllvm -relocation-model=static ; RUN: ld.lld %t.o -o %t-out -save-temps -r -mllvm -relocation-model=static
; RUN: llvm-readobj -r %t-out.lto.o | FileCheck %s --check-prefix=STATIC ; RUN: llvm-readobj -r %t-out.lto.o | FileCheck %s --check-prefix=STATIC
; PIC: R_X86_64_REX_GOTPCRELX foo ; PIC: R_X86_64_REX_GOTPCRELX foo
; STATIC: R_X86_64_PC32 foo ; STATIC: R_X86_64_PC32 foo
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foo = external global i32 @foo = external global i32
define i32 @main() { define i32 @main() {
%t = load i32, i32* @foo %t = load i32, i32* @foo
ret i32 %t ret i32 %t
} }

lld/test/ELF/lto/resolution.ll

Show All 15 Lines
; CHECK-NEXT: Link: 0 ; CHECK-NEXT: Link: 0
; CHECK-NEXT: Info: 0 ; CHECK-NEXT: Info: 0
; CHECK-NEXT: AddressAlignment: 1 ; CHECK-NEXT: AddressAlignment: 1
; CHECK-NEXT: EntrySize: 0 ; CHECK-NEXT: EntrySize: 0
; CHECK-NEXT: SectionData ( ; CHECK-NEXT: SectionData (
; CHECK-NEXT: 0000: 09000000 |{{.*}}| ; CHECK-NEXT: 0000: 09000000 |{{.*}}|
; CHECK-NEXT: ) ; CHECK-NEXT: )
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@a = weak global i32 8 @a = weak global i32 8

lld/test/ELF/lto/sample-profile.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: opt -module-summary %s -o %t1.o ; RUN: opt -module-summary %s -o %t1.o
; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o ; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o
; RUN: rm -f %t1.lto.o %t2.lto.o ; RUN: rm -f %t1.lto.o %t2.lto.o
; RUN: ld.lld --lto-sample-profile=%p/Inputs/sample-profile.prof %t1.o %t2.o -o %t3 ; RUN: ld.lld --lto-sample-profile=%p/Inputs/sample-profile.prof %t1.o %t2.o -o %t3
; RUN opt -S %t3.lto.o | FileCheck %s ; RUN opt -S %t3.lto.o | FileCheck %s
; RUN: rm -f %t1.lto.o %t2.lto.o ; RUN: rm -f %t1.lto.o %t2.lto.o
; RUN: ld.lld --plugin-opt=sample-profile=%p/Inputs/sample-profile.prof %t1.o %t2.o -o %t3 ; RUN: ld.lld --plugin-opt=sample-profile=%p/Inputs/sample-profile.prof %t1.o %t2.o -o %t3
; RUN opt -S %t3.lto.o | FileCheck %s ; RUN opt -S %t3.lto.o | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; CHECK: ProfileSummary ; CHECK: ProfileSummary
declare void @g(...) declare void @g(...)
declare void @h(...) declare void @h(...)
define void @f() { define void @f() {
entry: entry:
call void (...) @g() call void (...) @g()
call void (...) @h() call void (...) @h()
ret void ret void
} }

lld/test/ELF/lto/save-temps.ll

Show All 11 Lines
; RUN: rm -f a.out a.out.lto.bc a.out.lto.o ; RUN: rm -f a.out a.out.lto.bc a.out.lto.o
; RUN: ld.lld -shared -m elf_x86_64 %t.o %t2.o --plugin-opt=save-temps ; RUN: ld.lld -shared -m elf_x86_64 %t.o %t2.o --plugin-opt=save-temps
; RUN: llvm-nm a.out | FileCheck %s ; RUN: llvm-nm a.out | FileCheck %s
; RUN: llvm-nm a.out.0.0.preopt.bc | FileCheck %s ; RUN: llvm-nm a.out.0.0.preopt.bc | FileCheck %s
; RUN: llvm-nm a.out.lto.o | FileCheck %s ; RUN: llvm-nm a.out.lto.o | FileCheck %s
; RUN: llvm-dis a.out.0.0.preopt.bc ; RUN: llvm-dis a.out.0.0.preopt.bc
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @foo() { define void @foo() {
ret void ret void
} }
; CHECK: T bar ; CHECK: T bar
; CHECK: T foo ; CHECK: T foo

lld/test/ELF/lto/section-name.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld %t.o -o %t.so -shared ; RUN: ld.lld %t.o -o %t.so -shared
; RUN: llvm-readelf -S %t.so | FileCheck %s ; RUN: llvm-readelf -S %t.so | FileCheck %s
; RUN: ld.lld %t.o -o %t.so -shared --gc-sections ; RUN: ld.lld %t.o -o %t.so -shared --gc-sections
; RUN: llvm-readelf -S %t.so | FileCheck --check-prefix=GC %s ; RUN: llvm-readelf -S %t.so | FileCheck --check-prefix=GC %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foo = hidden global i32 42, section "foo_section" @foo = hidden global i32 42, section "foo_section"
@bar = hidden global i32 42, section "bar_section" @bar = hidden global i32 42, section "bar_section"
@zed = hidden global i32 42, section "zed_section" @zed = hidden global i32 42, section "zed_section"
@__start_foo_section = external global i32 @__start_foo_section = external global i32
@__stop_bar_section = external global i32 @__stop_bar_section = external global i32
Show All 19 Lines

lld/test/ELF/lto/setting-dso-local.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: not ld.lld -o %t %t1.o 2>&1 | FileCheck %s ; RUN: not ld.lld -o %t %t1.o 2>&1 | FileCheck %s
; CHECK: undefined hidden symbol: foobar ; CHECK: undefined hidden symbol: foobar
; We used to crash setting foobar to non-dso_local ; We used to crash setting foobar to non-dso_local
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foobar = external hidden global i32 @foobar = external hidden global i32
define i32* @_start() { define i32* @_start() {
ret i32* @foobar ret i32* @foobar
} }

lld/test/ELF/lto/shlib-undefined.ll

Show All 10 Lines
; CHECK-NEXT: Size: 1 ; CHECK-NEXT: Size: 1
; CHECK-NEXT: Binding: Global (0x1) ; CHECK-NEXT: Binding: Global (0x1)
; CHECK-NEXT: Type: Function ; CHECK-NEXT: Type: Function
; CHECK-NEXT: Other: 0 ; CHECK-NEXT: Other: 0
; CHECK-NEXT: Section: .text ; CHECK-NEXT: Section: .text
; CHECK-NEXT: } ; CHECK-NEXT: }
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @_start() { define void @_start() {
ret void ret void
} }
define void @__progname() { define void @__progname() {
ret void ret void
} }

lld/test/ELF/lto/start-lib.ll

Show All 13 Lines
; TEST2: Name: bar ; TEST2: Name: bar
; TEST2-NOT: Name: foo ; TEST2-NOT: Name: foo
; ;
; RUN: ld.lld -shared -o %t3 %t1.o --start-lib %t2.o %t3.o ; RUN: ld.lld -shared -o %t3 %t1.o --start-lib %t2.o %t3.o
; RUN: llvm-readobj --symbols %t3 | FileCheck --check-prefix=TEST3 %s ; RUN: llvm-readobj --symbols %t3 | FileCheck --check-prefix=TEST3 %s
; TEST3-NOT: Name: bar ; TEST3-NOT: Name: bar
; TEST3-NOT: Name: foo ; TEST3-NOT: Name: foo
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @_start() { define void @_start() {
ret void ret void
} }

lld/test/ELF/lto/thin-archivecollision.ll

Show All 17 Lines
; Check we handle this case correctly even in presence of --whole-archive. ; Check we handle this case correctly even in presence of --whole-archive.
; RUN: ld.lld %t.o --whole-archive %t.a -o %t ; RUN: ld.lld %t.o --whole-archive %t.a -o %t
; RUN: llvm-nm %t | FileCheck %s ; RUN: llvm-nm %t | FileCheck %s
; CHECK: T _start ; CHECK: T _start
; CHECK: T blah ; CHECK: T blah
; CHECK: T foo ; CHECK: T foo
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-scei-ps4" target triple = "x86_64-scei-ps4"
define i32 @_start() { define i32 @_start() {
entry: entry:
%call = call i32 @foo(i32 23) %call = call i32 @foo(i32 23)
%call1 = call i32 @blah(i32 37) %call1 = call i32 @blah(i32 37)
ret i32 0 ret i32 0
} }
declare i32 @foo(i32) #1 declare i32 @foo(i32) #1
declare i32 @blah(i32) #1 declare i32 @blah(i32) #1

lld/test/ELF/lto/thinlto-cant-write-index.ll

; REQUIRES: x86 ; REQUIRES: x86
; Basic ThinLTO tests. ; Basic ThinLTO tests.
; RUN: opt -module-summary %s -o %t1.o ; RUN: opt -module-summary %s -o %t1.o
; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o ; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o
; Ensure lld generates error if unable to write to index files ; Ensure lld generates error if unable to write to index files
; RUN: rm -f %t2.o.thinlto.bc ; RUN: rm -f %t2.o.thinlto.bc
; RUN: touch %t2.o.thinlto.bc ; RUN: touch %t2.o.thinlto.bc
; RUN: chmod u-w %t2.o.thinlto.bc ; RUN: chmod u-w %t2.o.thinlto.bc
; RUN: not ld.lld --plugin-opt=thinlto-index-only -shared %t1.o %t2.o -o %t3 2>&1 | FileCheck %s ; RUN: not ld.lld --plugin-opt=thinlto-index-only -shared %t1.o %t2.o -o %t3 2>&1 | FileCheck %s
; RUN: chmod u+w %t2.o.thinlto.bc ; RUN: chmod u+w %t2.o.thinlto.bc
; CHECK: cannot open {{.*}}2.o.thinlto.bc: {{P|p}}ermission denied ; CHECK: cannot open {{.*}}2.o.thinlto.bc: {{P|p}}ermission denied
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @g(...) declare void @g(...)
define void @f() { define void @f() {
entry: entry:
call void (...) @g() call void (...) @g()
ret void ret void
} }

lld/test/ELF/lto/thinlto-debug-fission.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: opt %s -o %t1.o ; RUN: opt %s -o %t1.o
; RUN: rm -rf %T/dwo ; RUN: rm -rf %T/dwo
; Test to ensure that --plugin-opt=dwo_dir=$DIR creates .dwo files under $DIR ; Test to ensure that --plugin-opt=dwo_dir=$DIR creates .dwo files under $DIR
; RUN: ld.lld --plugin-opt=dwo_dir=%T/dwo -shared %t1.o -o /dev/null ; RUN: ld.lld --plugin-opt=dwo_dir=%T/dwo -shared %t1.o -o /dev/null
; RUN: llvm-readobj -h %T/dwo/0.dwo | FileCheck %s ; RUN: llvm-readobj -h %T/dwo/0.dwo | FileCheck %s
; CHECK: Format: ELF64-x86-64 ; CHECK: Format: ELF64-x86-64
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @g(...) declare void @g(...)
define void @f() { define void @f() {
entry: entry:
call void (...) @g() call void (...) @g()
ret void ret void
} }

lld/test/ELF/lto/thinlto-emit-imports.ll

Show All 37 Lines
; RUN: rm -f %t1.o.imports ; RUN: rm -f %t1.o.imports
; RUN: rm -f %t2.o.imports ; RUN: rm -f %t2.o.imports
; RUN: rm -f %t3.o.imports ; RUN: rm -f %t3.o.imports
; RUN: ld.lld --plugin-opt=thinlto-emit-imports-files -shared %t1.o %t2.o %t3.o -o %t4 ; RUN: ld.lld --plugin-opt=thinlto-emit-imports-files -shared %t1.o %t2.o %t3.o -o %t4
; RUN: not ls %t1.o.imports ; RUN: not ls %t1.o.imports
; RUN: not ls %t2.o.imports ; RUN: not ls %t2.o.imports
; RUN: not ls %t3.o.imports ; RUN: not ls %t3.o.imports
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @g(...) declare void @g(...)
define void @f() { define void @f() {
entry: entry:
call void (...) @g() call void (...) @g()
ret void ret void
} }

lld/test/ELF/lto/thinlto-index-file.ll

; REQUIRES: x86 ; REQUIRES: x86
; Basic ThinLTO tests. ; Basic ThinLTO tests.
; RUN: opt -module-summary %s -o %t1.o ; RUN: opt -module-summary %s -o %t1.o
; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o ; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o
; RUN: opt -module-summary %p/Inputs/thinlto_empty.ll -o %t3.o ; RUN: opt -module-summary %p/Inputs/thinlto_empty.ll -o %t3.o
; Ensure lld writes linked files to linked objects file ; Ensure lld writes linked files to linked objects file
; RUN: ld.lld --plugin-opt=thinlto-index-only=%t.idx -shared %t1.o %t2.o %t3.o -o %t4 ; RUN: ld.lld --plugin-opt=thinlto-index-only=%t.idx -shared %t1.o %t2.o %t3.o -o %t4
; RUN: FileCheck %s < %t.idx ; RUN: FileCheck %s < %t.idx
; CHECK: {{.*}}thinlto-index-file.ll.tmp1.o ; CHECK: {{.*}}thinlto-index-file.ll.tmp1.o
; CHECK: {{.*}}thinlto-index-file.ll.tmp2.o ; CHECK: {{.*}}thinlto-index-file.ll.tmp2.o
; CHECK: {{.*}}thinlto-index-file.ll.tmp3.o ; CHECK: {{.*}}thinlto-index-file.ll.tmp3.o
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @g(...) declare void @g(...)
define void @f() { define void @f() {
entry: entry:
call void (...) @g() call void (...) @g()
ret void ret void
} }

lld/test/ELF/lto/thinlto-index-only.ll

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
; BACKEND2-NEXT: </MODULE_STRTAB_BLOCK ; BACKEND2-NEXT: </MODULE_STRTAB_BLOCK
; BACKEND2-NEXT: <GLOBALVAL_SUMMARY_BLOCK ; BACKEND2-NEXT: <GLOBALVAL_SUMMARY_BLOCK
; BACKEND2-NEXT: <VERSION ; BACKEND2-NEXT: <VERSION
; BACKEND2-NEXT: <FLAGS ; BACKEND2-NEXT: <FLAGS
; BACKEND2-NEXT: <VALUE_GUID op0=1 op1=-5300342847281564238 ; BACKEND2-NEXT: <VALUE_GUID op0=1 op1=-5300342847281564238
; BACKEND2-NEXT: <COMBINED ; BACKEND2-NEXT: <COMBINED
; BACKEND2-NEXT: </GLOBALVAL_SUMMARY_BLOCK ; BACKEND2-NEXT: </GLOBALVAL_SUMMARY_BLOCK
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @g(...) declare void @g(...)
define void @f() { define void @f() {
entry: entry:
call void (...) @g() call void (...) @g()
ret void ret void
} }

lld/test/ELF/lto/thinlto-no-index.ll

; REQUIRES: x86 ; REQUIRES: x86
; Basic ThinLTO tests. ; Basic ThinLTO tests.
; RUN: opt -module-summary %s -o %t1.o ; RUN: opt -module-summary %s -o %t1.o
; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o ; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o
; RUN: opt -module-summary %p/Inputs/thinlto_empty.ll -o %t3.o ; RUN: opt -module-summary %p/Inputs/thinlto_empty.ll -o %t3.o
; Ensure lld doesn't generates index files when thinlto-index-only is not enabled ; Ensure lld doesn't generates index files when thinlto-index-only is not enabled
; RUN: rm -f %t1.o.thinlto.bc %t2.o.thinlto.bc %t3.o.thinlto.bc ; RUN: rm -f %t1.o.thinlto.bc %t2.o.thinlto.bc %t3.o.thinlto.bc
; RUN: ld.lld -shared %t1.o %t2.o %t3.o -o %t4 ; RUN: ld.lld -shared %t1.o %t2.o %t3.o -o %t4
; RUN: not ls %t1.o.thinlto.bc ; RUN: not ls %t1.o.thinlto.bc
; RUN: not ls %t2.o.thinlto.bc ; RUN: not ls %t2.o.thinlto.bc
; RUN: not ls %t3.o.thinlto.bc ; RUN: not ls %t3.o.thinlto.bc
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @g(...) declare void @g(...)
define void @f() { define void @f() {
entry: entry:
call void (...) @g() call void (...) @g()
ret void ret void
} }

lld/test/ELF/lto/thinlto-obj-path.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: opt -module-summary %s -o %t1.o ; RUN: opt -module-summary %s -o %t1.o
; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o ; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o
; Test to ensure that thinlto-index-only with obj-path creates the file. ; Test to ensure that thinlto-index-only with obj-path creates the file.
; RUN: rm -f %t4.o ; RUN: rm -f %t4.o
; RUN: ld.lld --plugin-opt=thinlto-index-only --plugin-opt=obj-path=%t4.o -shared %t1.o %t2.o -o %t3 ; RUN: ld.lld --plugin-opt=thinlto-index-only --plugin-opt=obj-path=%t4.o -shared %t1.o %t2.o -o %t3
; RUN: llvm-readobj -h %t4.o | FileCheck %s ; RUN: llvm-readobj -h %t4.o | FileCheck %s
; RUN: llvm-nm %t4.o 2>&1 | FileCheck %s -check-prefix=NO-SYMBOLS ; RUN: llvm-nm %t4.o 2>&1 | FileCheck %s -check-prefix=NO-SYMBOLS
; NO-SYMBOLS: no symbols ; NO-SYMBOLS: no symbols
; CHECK: Format: ELF64-x86-64 ; CHECK: Format: ELF64-x86-64
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @g(...) declare void @g(...)
define void @f() { define void @f() {
entry: entry:
call void (...) @g() call void (...) @g()
ret void ret void
} }

lld/test/ELF/lto/thinlto-object-suffix-replace.ll

Show All 30 Lines
; If filename does not end with old suffix, no suffix change should occur, ; If filename does not end with old suffix, no suffix change should occur,
; so ".thinlto.bc" will simply be appended to the input file name. ; so ".thinlto.bc" will simply be appended to the input file name.
; RUN: rm -f %t1.thinlink.bc.thinlto.bc ; RUN: rm -f %t1.thinlink.bc.thinlto.bc
; RUN: ld.lld --plugin-opt=thinlto-index-only \ ; RUN: ld.lld --plugin-opt=thinlto-index-only \
; RUN: --plugin-opt=thinlto-object-suffix-replace=".abc;.o" -shared %t1.thinlink.bc -o /dev/null ; RUN: --plugin-opt=thinlto-object-suffix-replace=".abc;.o" -shared %t1.thinlink.bc -o /dev/null
; RUN: ls %t1.thinlink.bc.thinlto.bc ; RUN: ls %t1.thinlink.bc.thinlto.bc
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @f() { define void @f() {
entry: entry:
ret void ret void
} }
!llvm.dbg.cu = !{} !llvm.dbg.cu = !{}
!1 = !{i32 2, !"Debug Info Version", i32 3} !1 = !{i32 2, !"Debug Info Version", i32 3}
!llvm.module.flags = !{!1} !llvm.module.flags = !{!1}

lld/test/ELF/lto/thinlto-prefix-replace.ll

; REQUIRES: x86 ; REQUIRES: x86
; Check that changing the output path via thinlto-prefix-replace works ; Check that changing the output path via thinlto-prefix-replace works
; RUN: mkdir -p %t/oldpath ; RUN: mkdir -p %t/oldpath
; RUN: opt -module-summary %s -o %t/oldpath/thinlto_prefix_replace.o ; RUN: opt -module-summary %s -o %t/oldpath/thinlto_prefix_replace.o
; Ensure that there is no existing file at the new path, so we properly ; Ensure that there is no existing file at the new path, so we properly
; test the creation of the new file there. ; test the creation of the new file there.
; RUN: rm -f %t/newpath/thinlto_prefix_replace.o.thinlto.bc ; RUN: rm -f %t/newpath/thinlto_prefix_replace.o.thinlto.bc
; RUN: ld.lld --plugin-opt=thinlto-index-only --plugin-opt=thinlto-prefix-replace="%t/oldpath/;%t/newpath/" -shared %t/oldpath/thinlto_prefix_replace.o -o %t/thinlto_prefix_replace ; RUN: ld.lld --plugin-opt=thinlto-index-only --plugin-opt=thinlto-prefix-replace="%t/oldpath/;%t/newpath/" -shared %t/oldpath/thinlto_prefix_replace.o -o %t/thinlto_prefix_replace
; RUN: ls %t/newpath/thinlto_prefix_replace.o.thinlto.bc ; RUN: ls %t/newpath/thinlto_prefix_replace.o.thinlto.bc
; Ensure that lld generates error if prefix replace option does not have 'old;new' format ; Ensure that lld generates error if prefix replace option does not have 'old;new' format
; RUN: rm -f %t/newpath/thinlto_prefix_replace.o.thinlto.bc ; RUN: rm -f %t/newpath/thinlto_prefix_replace.o.thinlto.bc
; RUN: not ld.lld --plugin-opt=thinlto-index-only --plugin-opt=thinlto-prefix-replace=abc:def -shared %t/oldpath/thinlto_prefix_replace.o -o %t/thinlto_prefix_replace 2>&1 | FileCheck %s --check-prefix=ERR ; RUN: not ld.lld --plugin-opt=thinlto-index-only --plugin-opt=thinlto-prefix-replace=abc:def -shared %t/oldpath/thinlto_prefix_replace.o -o %t/thinlto_prefix_replace 2>&1 | FileCheck %s --check-prefix=ERR
; ERR: --plugin-opt=thinlto-prefix-replace= expects 'old;new' format, but got abc:def ; ERR: --plugin-opt=thinlto-prefix-replace= expects 'old;new' format, but got abc:def
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @f() { define void @f() {
entry: entry:
ret void ret void
} }

lld/test/ELF/lto/thinlto.ll

Show All 18 Lines
; Then check without --thinlto-jobs (which currently default to hardware_concurrency) ; Then check without --thinlto-jobs (which currently default to hardware_concurrency)
; RUN: ld.lld -shared %t1.o %t2.o -o %t3 ; RUN: ld.lld -shared %t1.o %t2.o -o %t3
; RUN: llvm-nm %t31.lto.o | FileCheck %s --check-prefix=NM1 ; RUN: llvm-nm %t31.lto.o | FileCheck %s --check-prefix=NM1
; RUN: llvm-nm %t32.lto.o | FileCheck %s --check-prefix=NM2 ; RUN: llvm-nm %t32.lto.o | FileCheck %s --check-prefix=NM2
; NM1: T f ; NM1: T f
; NM2: T g ; NM2: T g
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @g(...) declare void @g(...)
define void @f() { define void @f() {
entry: entry:
call void (...) @g() call void (...) @g()
ret void ret void
} }

lld/test/ELF/lto/timepasses.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: env LLD_IN_TEST=0 ld.lld %t.o -o %t.so -shared -mllvm \ ; RUN: env LLD_IN_TEST=0 ld.lld %t.o -o %t.so -shared -mllvm \
; RUN: -time-passes 2>&1 | FileCheck %s ; RUN: -time-passes 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @patatino() { define void @patatino() {
ret void ret void
} }
; We should get the output of -time-passes even when full shutdown is not specified. ; We should get the output of -time-passes even when full shutdown is not specified.
; CHECK: Total Execution Time ; CHECK: Total Execution Time

lld/test/ELF/lto/tls-mixed.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: llvm-mc %p/Inputs/tls-mixed.s -o %t2.o -filetype=obj -triple=x86_64-pc-linux ; RUN: llvm-mc %p/Inputs/tls-mixed.s -o %t2.o -filetype=obj -triple=x86_64-pc-linux
; RUN: ld.lld %t1.o %t2.o -o %t.so -shared ; RUN: ld.lld %t1.o %t2.o -o %t.so -shared
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; Should not encounter TLS-ness mismatch for @foo ; Should not encounter TLS-ness mismatch for @foo
@foo = external thread_local global i32, align 4 @foo = external thread_local global i32, align 4

lld/test/ELF/lto/tls-preserve.ll

; TLS attribute needs to be preserved. ; TLS attribute needs to be preserved.
; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: ld.lld -shared %t1.o -o %t1 ; RUN: ld.lld -shared %t1.o -o %t1
; RUN: llvm-readobj --symbols %t1 | FileCheck %s ; RUN: llvm-readobj --symbols %t1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@tsp_int = thread_local global i32 1 @tsp_int = thread_local global i32 1
define void @_start() { define void @_start() {
%val = load i32, i32* @tsp_int %val = load i32, i32* @tsp_int
ret void ret void
} }
Show All 10 Lines

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

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: llvm-as %p/Inputs/type-merge.ll -o %t2.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: ld.lld %t.o %t2.o -o %t -shared -save-temps
; RUN: llvm-dis < %t.0.0.preopt.bc | FileCheck %s ; RUN: llvm-dis < %t.0.0.preopt.bc | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @foo() { define void @foo() {
call void @bar(i8* null) call void @bar(i8* null)
ret void ret void
} }
declare void @bar(i8*) declare void @bar(i8*)
Show All 11 Lines

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

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: llvm-as %p/Inputs/type-merge2.ll -o %t2.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: ld.lld %t.o %t2.o -o %t.so -shared -save-temps
; RUN: llvm-dis %t.so.0.0.preopt.bc -o - | FileCheck %s ; RUN: llvm-dis %t.so.0.0.preopt.bc -o - | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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 } %zed = type { i8 }
define void @foo() { define void @foo() {
call void @bar(%zed* null) call void @bar(%zed* null)
ret void ret void
} }
declare void @bar(%zed*) declare void @bar(%zed*)
Show All 12 Lines

lld/test/ELF/lto/undef-mixed.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-mc %p/Inputs/undef-mixed.s -o %t.o -filetype=obj -triple=x86_64-pc-linux ; RUN: llvm-mc %p/Inputs/undef-mixed.s -o %t.o -filetype=obj -triple=x86_64-pc-linux
; RUN: llvm-as %s -o %t2.o ; RUN: llvm-as %s -o %t2.o
; RUN: ld.lld %t2.o %t.o -o %t.so -shared ; RUN: ld.lld %t2.o %t.o -o %t.so -shared
; RUN: llvm-readobj --symbols %t.so | FileCheck %s ; RUN: llvm-readobj --symbols %t.so | FileCheck %s
; CHECK: Name: bar ; CHECK: Name: bar
; CHECK-NEXT: Value: ; CHECK-NEXT: Value:
; CHECK-NEXT: Size: 0 ; CHECK-NEXT: Size: 0
; CHECK-NEXT: Binding: Global ; CHECK-NEXT: Binding: Global
; CHECK-NEXT: Type: None ; CHECK-NEXT: Type: None
; CHECK-NEXT: Other: 0 ; CHECK-NEXT: Other: 0
; CHECK-NEXT: Section: .text ; CHECK-NEXT: Section: .text
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @bar() declare void @bar()
define void @foo() { define void @foo() {
call void @bar() call void @bar()
ret void ret void
} }

lld/test/ELF/lto/undef-weak.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %S/Inputs/archive.ll -o %t1.o ; RUN: llvm-as %S/Inputs/archive.ll -o %t1.o
; RUN: rm -f %t.a ; RUN: rm -f %t.a
; RUN: llvm-ar rcs %t.a %t1.o ; RUN: llvm-ar rcs %t.a %t1.o
; RUN: llvm-as %s -o %t2.o ; RUN: llvm-as %s -o %t2.o
; RUN: ld.lld %t2.o -o %t2.so %t.a -shared ; RUN: ld.lld %t2.o -o %t2.so %t.a -shared
; RUN: llvm-readobj --symbols %t2.so | FileCheck %s ; RUN: llvm-readobj --symbols %t2.so | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
declare extern_weak void @f() declare extern_weak void @f()
define void @foo() { define void @foo() {
call void @f() call void @f()
ret void ret void
} }
; We should not fetch the archive member. ; We should not fetch the archive member.
Show All 9 Lines

lld/test/ELF/lto/undef.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld %t.o -o %t.so -shared ; RUN: ld.lld %t.o -o %t.so -shared
; RUN: llvm-readobj --symbols %t.so | FileCheck %s ; RUN: llvm-readobj --symbols %t.so | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
declare void @bar() declare void @bar()
define void @foo() { define void @foo() {
call void @bar() call void @bar()
ret void ret void
} }
; CHECK: Name: bar ; CHECK: Name: bar
; CHECK-NEXT: Value: 0x0 ; CHECK-NEXT: Value: 0x0
; CHECK-NEXT: Size: 0 ; CHECK-NEXT: Size: 0
; CHECK-NEXT: Binding: Global ; CHECK-NEXT: Binding: Global
; CHECK-NEXT: Type: None ; CHECK-NEXT: Type: None
; CHECK-NEXT: Other: 0 ; CHECK-NEXT: Other: 0
; CHECK-NEXT: Section: Undefined ; CHECK-NEXT: Section: Undefined

lld/test/ELF/lto/undefined-puts.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-mc %p/Inputs/shared.s -o %t1.o -filetype=obj -triple=x86_64-unknown-linux ; RUN: llvm-mc %p/Inputs/shared.s -o %t1.o -filetype=obj -triple=x86_64-unknown-linux
; RUN: ld.lld %t1.o -o %t1.so -shared ; RUN: ld.lld %t1.o -o %t1.so -shared
; RUN: llvm-as %s -o %t2.o ; RUN: llvm-as %s -o %t2.o
; RUN: ld.lld %t1.so %t2.o -o %t ; RUN: ld.lld %t1.so %t2.o -o %t
; RUN: llvm-readobj --dyn-syms --dyn-relocations %t | FileCheck %s ; RUN: llvm-readobj --dyn-syms --dyn-relocations %t | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@.str = private unnamed_addr constant [6 x i8] c"blah\0A\00", align 1 @.str = private unnamed_addr constant [6 x i8] c"blah\0A\00", align 1
define i32 @_start() { define i32 @_start() {
%str = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i32 0, i32 0)) %str = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i32 0, i32 0))
ret i32 0 ret i32 0
} }
Show All 12 Lines

lld/test/ELF/lto/unnamed-addr-comdat.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld %t.o %t.o -o %t.so -save-temps -shared ; RUN: ld.lld %t.o %t.o -o %t.so -save-temps -shared
; RUN: llvm-dis %t.so.0.2.internalize.bc -o - | FileCheck %s ; RUN: llvm-dis %t.so.0.2.internalize.bc -o - | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
$foo = comdat any $foo = comdat any
@foo = linkonce_odr unnamed_addr constant i32 42, comdat @foo = linkonce_odr unnamed_addr constant i32 42, comdat
; CHECK: @foo = internal unnamed_addr constant i32 42, comdat ; CHECK: @foo = internal unnamed_addr constant i32 42, comdat

lld/test/ELF/lto/unnamed-addr-drop.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: llvm-as %S/Inputs/unnamed-addr-drop.ll -o %t2.o ; RUN: llvm-as %S/Inputs/unnamed-addr-drop.ll -o %t2.o
; RUN: ld.lld %t1.o %t2.o -o %t.so -save-temps -shared ; RUN: ld.lld %t1.o %t2.o -o %t.so -save-temps -shared
; RUN: llvm-dis %t.so.0.2.internalize.bc -o - | FileCheck %s ; RUN: llvm-dis %t.so.0.2.internalize.bc -o - | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
@foo = weak constant i32 41 @foo = weak constant i32 41
; Check that unnamed_addr is dropped during the merge. ; Check that unnamed_addr is dropped during the merge.
; CHECK: @foo = constant i32 42 ; CHECK: @foo = constant i32 42

lld/test/ELF/lto/unnamed-addr-lib.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: llvm-mc %p/Inputs/unnamed-addr-lib.s -o %t2.o -filetype=obj -triple=x86_64-pc-linux ; RUN: llvm-mc %p/Inputs/unnamed-addr-lib.s -o %t2.o -filetype=obj -triple=x86_64-pc-linux
; RUN: ld.lld %t2.o -shared -o %t2.so ; RUN: ld.lld %t2.o -shared -o %t2.so
; RUN: ld.lld %t.o %t2.so -o %t.so -save-temps -shared ; RUN: ld.lld %t.o %t2.so -o %t.so -save-temps -shared
; RUN: llvm-dis %t.so.0.2.internalize.bc -o - | FileCheck %s ; RUN: llvm-dis %t.so.0.2.internalize.bc -o - | FileCheck %s
; This documents a small limitation of lld's internalization logic. We decide ; This documents a small limitation of lld's internalization logic. We decide
; that bar should be in the symbol table because if it is it will preempt the ; that bar should be in the symbol table because if it is it will preempt the
; one in the shared library. ; one in the shared library.
; We could add one extra bit for ODR so that we know that preemption is not ; We could add one extra bit for ODR so that we know that preemption is not
; necessary, but that is probably not worth it. ; necessary, but that is probably not worth it.
; CHECK: @foo = internal unnamed_addr constant i8 42 ; CHECK: @foo = internal unnamed_addr constant i8 42
; CHECK: @bar = weak_odr unnamed_addr constant i8 42 ; CHECK: @bar = weak_odr unnamed_addr constant i8 42
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foo = linkonce_odr unnamed_addr constant i8 42 @foo = linkonce_odr unnamed_addr constant i8 42
@bar = linkonce_odr unnamed_addr constant i8 42 @bar = linkonce_odr unnamed_addr constant i8 42

lld/test/ELF/lto/unnamed-addr.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld %t.o -o %t.so -save-temps -shared ; RUN: ld.lld %t.o -o %t.so -save-temps -shared
; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s ; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
@a = internal unnamed_addr constant i8 42 @a = internal unnamed_addr constant i8 42
define i8* @f() { define i8* @f() {
ret i8* @a ret i8* @a
} }
; CHECK: @a = internal unnamed_addr constant i8 42 ; CHECK: @a = internal unnamed_addr constant i8 42

lld/test/ELF/lto/verify-invalid.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld %t.o -o %t2 -mllvm -debug-pass=Arguments \ ; RUN: ld.lld %t.o -o %t2 -mllvm -debug-pass=Arguments \
; RUN: 2>&1 | FileCheck -check-prefix=DEFAULT %s ; RUN: 2>&1 | FileCheck -check-prefix=DEFAULT %s
; RUN: ld.lld %t.o -o %t2 -mllvm -debug-pass=Arguments \ ; RUN: ld.lld %t.o -o %t2 -mllvm -debug-pass=Arguments \
; RUN: -disable-verify 2>&1 | FileCheck -check-prefix=DISABLE %s ; RUN: -disable-verify 2>&1 | FileCheck -check-prefix=DISABLE %s
; RUN: ld.lld %t.o -o %t2 -mllvm -debug-pass=Arguments \ ; RUN: ld.lld %t.o -o %t2 -mllvm -debug-pass=Arguments \
; RUN: --plugin-opt=disable-verify 2>&1 | FileCheck -check-prefix=DISABLE %s ; RUN: --plugin-opt=disable-verify 2>&1 | FileCheck -check-prefix=DISABLE %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @_start() { define void @_start() {
ret void ret void
} }
; -disable-verify should disable the verification of bitcode. ; -disable-verify should disable the verification of bitcode.
; DEFAULT: Pass Arguments: {{.*}} -verify {{.*}} -verify ; DEFAULT: Pass Arguments: {{.*}} -verify {{.*}} -verify
; DISABLE-NOT: Pass Arguments: {{.*}} -verify {{.*}} -verify ; DISABLE-NOT: Pass Arguments: {{.*}} -verify {{.*}} -verify

lld/test/ELF/lto/version-script.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: echo "VERSION_1.0{ global: foo; local: *; }; VERSION_2.0{ global: bar; local: *; };" > %t.script ; RUN: echo "VERSION_1.0{ global: foo; local: *; }; VERSION_2.0{ global: bar; local: *; };" > %t.script
; RUN: ld.lld %t.o -o %t2 -shared --version-script %t.script -save-temps ; RUN: ld.lld %t.o -o %t2 -shared --version-script %t.script -save-temps
; RUN: llvm-dis < %t2.0.0.preopt.bc | FileCheck %s ; RUN: llvm-dis < %t2.0.0.preopt.bc | FileCheck %s
; RUN: llvm-readobj -V --dyn-syms %t2 | FileCheck --check-prefix=DSO %s ; RUN: llvm-readobj -V --dyn-syms %t2 | FileCheck --check-prefix=DSO %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @foo() { define void @foo() {
ret void ret void
} }
define void @bar() { define void @bar() {
ret void ret void
} }
Show All 33 Lines

lld/test/ELF/lto/version-script2.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: echo "VER1 {};" > %t.script ; RUN: echo "VER1 {};" > %t.script
; RUN: ld.lld %t.o -o %t.so -shared --version-script %t.script ; RUN: ld.lld %t.o -o %t.so -shared --version-script %t.script
; RUN: llvm-readobj --dyn-syms %t.so | FileCheck %s ; RUN: llvm-readobj --dyn-syms %t.so | FileCheck %s
; test that we have the correct version. ; test that we have the correct version.
; CHECK: Name: foo@@VER1 ( ; CHECK: Name: foo@@VER1 (
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
module asm ".global foo" module asm ".global foo"
module asm "foo:" module asm "foo:"
module asm ".symver foo,foo@@@VER1" module asm ".symver foo,foo@@@VER1"

lld/test/ELF/lto/visibility.ll

Show All 19 Lines
; CHECK-NEXT: Size: 0 ; CHECK-NEXT: Size: 0
; CHECK-NEXT: Binding: Local ; CHECK-NEXT: Binding: Local
; CHECK-NEXT: Type: None ; CHECK-NEXT: Type: None
; CHECK-NEXT: Other [ (0x2) ; CHECK-NEXT: Other [ (0x2)
; CHECK-NEXT: STV_HIDDEN ; CHECK-NEXT: STV_HIDDEN
; CHECK-NEXT: ] ; CHECK-NEXT: ]
; CHECK-NEXT: Section: .data ; CHECK-NEXT: Section: .data
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare hidden void @g() declare hidden void @g()
; IR: declare hidden void @g() ; IR: declare hidden void @g()
define void @f() { define void @f() {
call void @g() call void @g()
ret void ret void
} }
@a = weak hidden global i32 42 @a = weak hidden global i32 42

lld/test/ELF/lto/weak.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld %t.o %t.o -o %t.so -shared ; RUN: ld.lld %t.o %t.o -o %t.so -shared
; RUN: llvm-readobj --symbols %t.so | FileCheck %s ; RUN: llvm-readobj --symbols %t.so | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define weak void @f() { define weak void @f() {
ret void ret void
} }
; CHECK: Name: f ; CHECK: Name: f
; CHECK-NEXT: Value: 0x1000 ; CHECK-NEXT: Value: 0x1000
; CHECK-NEXT: Size: 1 ; CHECK-NEXT: Size: 1
; CHECK-NEXT: Binding: Weak ; CHECK-NEXT: Binding: Weak

lld/test/ELF/lto/weakodr-visibility.ll

Show All 26 Lines
; Now swap the files order. ; Now swap the files order.
; RUN: ld.lld %t2.o %t1.o -o %t.so -shared ; RUN: ld.lld %t2.o %t1.o -o %t.so -shared
; RUN: llvm-readobj --symbols %t.so | FileCheck %s ; RUN: llvm-readobj --symbols %t.so | FileCheck %s
; RUN: llvm-objdump -d %t.so | FileCheck %s --check-prefix=SECOND ; RUN: llvm-objdump -d %t.so | FileCheck %s --check-prefix=SECOND
; SECOND: foo: ; SECOND: foo:
; SECOND-NEXT: movl $42, %eax ; SECOND-NEXT: movl $42, %eax
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define weak_odr i32 @foo(i8* %this) { define weak_odr i32 @foo(i8* %this) {
ret i32 41 ret i32 41
} }

lld/test/ELF/lto/wrap-1.ll

Show All 17 Lines
; CHECK-NEXT: Type: Function ; CHECK-NEXT: Type: Function
; Make sure that the 'r' (linker redefined) bit is set for bar and __wrap_bar ; Make sure that the 'r' (linker redefined) bit is set for bar and __wrap_bar
; in the resolutions file. ; in the resolutions file.
; RESOLS: ,bar,xr ; RESOLS: ,bar,xr
; RESOLS: ,__wrap_bar,plx ; RESOLS: ,__wrap_bar,plx
; RESOLS: ,__real_bar,plxr ; RESOLS: ,__real_bar,plxr
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @bar() declare void @bar()
define void @_start() { define void @_start() {
call void @bar() call void @bar()
ret void ret void
} }
define void @__wrap_bar() { define void @__wrap_bar() {
ret void ret void
} }
define void @__real_bar() { define void @__real_bar() {
ret void ret void
} }

lld/test/ELF/lto/wrap-2.ll

Show All 30 Lines
; BIND-NEXT: Value: ; BIND-NEXT: Value:
; BIND-NEXT: Size: ; BIND-NEXT: Size:
; BIND-NEXT: Binding: Local ; BIND-NEXT: Binding: Local
; BIND: Name: __wrap_bar ; BIND: Name: __wrap_bar
; BIND-NEXT: Value: ; BIND-NEXT: Value:
; BIND-NEXT: Size: ; BIND-NEXT: Size:
; BIND-NEXT: Binding: Local ; BIND-NEXT: Binding: Local
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @bar() declare void @bar()
declare void @__real_bar() declare void @__real_bar()
define void @foo() { define void @foo() {
call void @bar() call void @bar()
call void @__real_bar() call void @__real_bar()
ret void ret void
} }

lld/test/wasm/lto/incompatible.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.bc ; RUN: llvm-as %s -o %t.bc
; RUN: not wasm-ld %t.bc -o out.wasm 2>&1 | FileCheck %s ; RUN: not wasm-ld %t.bc -o out.wasm 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; CHECK: {{.*}}incompatible.ll.tmp.bc: machine type must be wasm32 ; CHECK: {{.*}}incompatible.ll.tmp.bc: machine type must be wasm32

llvm/lib/Target/X86/X86TargetMachine.cpp

Show First 20 Lines • Show All 111 Lines • ▼ Show 20 Linesstatic std::string computeDataLayout(const Triple &TT) {
Ret += DataLayout::getManglingComponent(TT); Ret += DataLayout::getManglingComponent(TT);
// X86 and x32 have 32 bit pointers. // X86 and x32 have 32 bit pointers.
if ((TT.isArch64Bit() && if ((TT.isArch64Bit() &&
(TT.getEnvironment() == Triple::GNUX32 || TT.isOSNaCl())) || (TT.getEnvironment() == Triple::GNUX32 || TT.isOSNaCl())) ||
!TT.isArch64Bit()) !TT.isArch64Bit())
Ret += "-p:32:32"; Ret += "-p:32:32";
// Address spaces for 32 bit signed, 32 bit unsigned, and 64 bit pointers.
Ret += "-p270:32:32-p271:32:32-p272:64:64";
lebedev.riUnsubmitted
Not Done
ReplyInline Actions

I may be wrong but this seems to not match what has been said in the responses to RFC.

lebedev.ri: I may be wrong but this seems to not match what has been said in the responses to RFC.
// Some ABIs align 64 bit integers and doubles to 64 bits, others to 32. // Some ABIs align 64 bit integers and doubles to 64 bits, others to 32.
if (TT.isArch64Bit() || TT.isOSWindows() || TT.isOSNaCl()) if (TT.isArch64Bit() || TT.isOSWindows() || TT.isOSNaCl())
Ret += "-i64:64"; Ret += "-i64:64";
else if (TT.isOSIAMCU()) else if (TT.isOSIAMCU())
Ret += "-i64:32-f64:32"; Ret += "-i64:32-f64:32";
else else
Ret += "-f64:32:64"; Ret += "-f64:32:64";
▲ Show 20 Lines • Show All 408 Lines • Show Last 20 Lines

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

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@a = global i32 42 @a = global i32 42

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

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@a = external global i32 @a = external global i32
@d = global i32* @a @d = global i32* @a

llvm/test/LTO/Resolution/X86/Inputs/appending-var-2.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
%"foo" = type { i8 } %"foo" = type { i8 }
@llvm.used = appending global [1 x i8*] [i8* bitcast (i32 (%"foo"*)* @bar to i8*)], section "llvm.metadata" @llvm.used = appending global [1 x i8*] [i8* bitcast (i32 (%"foo"*)* @bar to i8*)], section "llvm.metadata"
; Function Attrs: norecurse nounwind readnone uwtable ; Function Attrs: norecurse nounwind readnone uwtable
define dso_local i32 @bar(%"foo"* nocapture readnone %this) align 2 !type !0 { define dso_local i32 @bar(%"foo"* nocapture readnone %this) align 2 !type !0 {
entry: entry:
ret i32 0 ret i32 0
} }
!0 = !{i64 0, !"typeid1"} !0 = !{i64 0, !"typeid1"}

llvm/test/LTO/Resolution/X86/Inputs/comdat-mixed-lto.ll

; ModuleID = 'comdat-mixed-lto1.o' ; ModuleID = 'comdat-mixed-lto1.o'
source_filename = "comdat-mixed-lto1.cpp" source_filename = "comdat-mixed-lto1.cpp"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
%"class.Test::ptr" = type { i32 } %"class.Test::ptr" = type { i32 }
$C = comdat any $C = comdat any
@C = linkonce_odr global %"class.Test::ptr" zeroinitializer, comdat, align 4 @C = linkonce_odr global %"class.Test::ptr" zeroinitializer, comdat, align 4
@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @__cxx_global_var_init, i8* bitcast (%"class.Test::ptr"* @C to i8*) }] @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @__cxx_global_var_init, i8* bitcast (%"class.Test::ptr"* @C to i8*) }]
Show All 12 Lines

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

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
$c2 = comdat any $c2 = comdat any
$c1 = comdat any $c1 = comdat any
; This is only present in this file. The linker will keep $c1 from the first ; This is only present in this file. The linker will keep $c1 from the first
; file and this will be undefined. ; file and this will be undefined.
@will_be_undefined = global i32 1, comdat($c1) @will_be_undefined = global i32 1, comdat($c1)
Show All 19 Lines

llvm/test/LTO/Resolution/X86/Inputs/common2.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@v = common global i16 0, align 4 @v = common global i16 0, align 4
define i16 *@bar() { define i16 *@bar() {
ret i16 *@v ret i16 *@v
} }

llvm/test/LTO/Resolution/X86/Inputs/commons.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@x = global i32 42, align 4 @x = global i32 42, align 4

llvm/test/LTO/Resolution/X86/Inputs/dead-strip-alias.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@external = global i8 42 @external = global i8 42

llvm/test/LTO/Resolution/X86/Inputs/dead-strip-fulllto.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @live1() { define void @live1() {
call void @live2() call void @live2()
ret void ret void
} }
declare void @live2() declare void @live2()
Show All 15 Lines

llvm/test/LTO/Resolution/X86/Inputs/intrinsic.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
%foo = type { } %foo = type { }
declare <4 x %foo*> @llvm.masked.load.v4p0foo.p0v4p0foo(<4 x %foo*>*, i32, <4 x i1>, <4 x %foo*>) declare <4 x %foo*> @llvm.masked.load.v4p0foo.p0v4p0foo(<4 x %foo*>*, i32, <4 x i1>, <4 x %foo*>)

llvm/test/LTO/Resolution/X86/Inputs/link-odr-availextern-ae.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define available_externally i32 @f() { define available_externally i32 @f() {
ret i32 2 ret i32 2
} }

llvm/test/LTO/Resolution/X86/Inputs/link-odr-availextern-odr.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define linkonce_odr i32 @f() { define linkonce_odr i32 @f() {
ret i32 2 ret i32 2
} }

llvm/test/LTO/Resolution/X86/Inputs/mixed_lto.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare i32 @g() declare i32 @g()
define i32 @main() { define i32 @main() {
call i32 @g() call i32 @g()
ret i32 0 ret i32 0
} }

llvm/test/LTO/Resolution/X86/Inputs/mod-asm-used.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foo = global i32 1, align 4 @foo = global i32 1, align 4

llvm/test/LTO/Resolution/X86/Inputs/not-prevailing.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @bar() { define void @bar() {
ret void ret void
} }

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

Show All 13 Lines
; RES: 1.o{{$}} ; RES: 1.o{{$}}
; RES-NEXT: {{^}}-r={{.*}}1.o,c,p{{$}} ; RES-NEXT: {{^}}-r={{.*}}1.o,c,p{{$}}
; RES-NEXT: {{^}}-r={{.*}}1.o,a,p{{$}} ; RES-NEXT: {{^}}-r={{.*}}1.o,a,p{{$}}
; RES-NEXT: {{^}}-r={{.*}}1.o,b,{{$}} ; RES-NEXT: {{^}}-r={{.*}}1.o,b,{{$}}
; RES-NEXT: 2.o{{$}} ; RES-NEXT: 2.o{{$}}
; RES-NEXT: {{^}}-r={{.*}}2.o,a,{{$}} ; RES-NEXT: {{^}}-r={{.*}}2.o,a,{{$}}
; RES-NEXT: {{^}}-r={{.*}}2.o,d,px{{$}} ; RES-NEXT: {{^}}-r={{.*}}2.o,d,px{{$}}
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@a = weak alias i32, i32* @b @a = weak alias i32, i32* @b
@b = alias i32, i32* @c @b = alias i32, i32* @c
@c = global i32 1 @c = global i32 1

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

Show All 9 Lines
; CHECK-NOT: alias ; CHECK-NOT: alias
; RES: 2.o{{$}} ; RES: 2.o{{$}}
; RES: {{^}}-r={{.*}}2.o,a,px{{$}} ; RES: {{^}}-r={{.*}}2.o,a,px{{$}}
; RES: 1.o{{$}} ; RES: 1.o{{$}}
; RES: {{^}}-r={{.*}}1.o,b,px{{$}} ; RES: {{^}}-r={{.*}}1.o,b,px{{$}}
; RES: {{^}}-r={{.*}}1.o,a,{{$}} ; RES: {{^}}-r={{.*}}1.o,a,{{$}}
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@a = weak alias i32, i32* @b @a = weak alias i32, i32* @b
@b = global i32 1 @b = global i32 1

llvm/test/LTO/Resolution/X86/appending-var.ll

; Check we don't crash when linking a global variable with appending linkage ; Check we don't crash when linking a global variable with appending linkage
; if the types in their elements don't have a straightforward mapping, forcing ; if the types in their elements don't have a straightforward mapping, forcing
; us to use bitcasts. ; us to use bitcasts.
; RUN: opt %s -o %t1.o ; RUN: opt %s -o %t1.o
; RUN: opt %p/Inputs/appending-var-2.ll -o %t2.o ; RUN: opt %p/Inputs/appending-var-2.ll -o %t2.o
; RUN: llvm-lto2 run -o %t3.o %t1.o %t2.o -r %t1.o,bar, -r %t2.o,bar,px ; RUN: llvm-lto2 run -o %t3.o %t1.o %t2.o -r %t1.o,bar, -r %t2.o,bar,px
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
%"foo.1" = type { i8, i8 } %"foo.1" = type { i8, i8 }
declare dso_local i32 @bar(%"foo.1"* nocapture readnone %this) local_unnamed_addr declare dso_local i32 @bar(%"foo.1"* nocapture readnone %this) local_unnamed_addr
@llvm.used = appending global [1 x i8*] [i8* bitcast (i32 (%"foo.1"*)* @bar to i8*)], section "llvm.metadata" @llvm.used = appending global [1 x i8*] [i8* bitcast (i32 (%"foo.1"*)* @bar to i8*)], section "llvm.metadata"

llvm/test/LTO/Resolution/X86/asm-output.ll

; Test the ability to emit assembly code from the resolution-based LTO API ; Test the ability to emit assembly code from the resolution-based LTO API
; ;
; RUN: llvm-as < %s > %t1.bc ; RUN: llvm-as < %s > %t1.bc
; ;
; RUN: llvm-lto2 run -filetype=asm -r %t1.bc,main,px -o %t2 %t1.bc ; RUN: llvm-lto2 run -filetype=asm -r %t1.bc,main,px -o %t2 %t1.bc
; RUN: FileCheck --check-prefix=ASM %s < %t2.0 ; RUN: FileCheck --check-prefix=ASM %s < %t2.0
; RUN: llvm-lto2 run -filetype=obj -r %t1.bc,main,px -o %t2 %t1.bc ; RUN: llvm-lto2 run -filetype=obj -r %t1.bc,main,px -o %t2 %t1.bc
; RUN: llvm-objdump -d %t2.0 | FileCheck --check-prefix=ASM %s ; RUN: llvm-objdump -d %t2.0 | FileCheck --check-prefix=ASM %s
; ;
; ASM: main: ; ASM: main:
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i32 @main() { define i32 @main() {
entry: entry:
ret i32 23 ret i32 23
} }

llvm/test/LTO/Resolution/X86/available-externally.ll

; RUN: opt -module-summary -o %t.bc %s ; RUN: opt -module-summary -o %t.bc %s
; RUN: llvm-lto2 run %t.bc -r %t.bc,foo,px -r %t.bc,bar, -o %t2 ; RUN: llvm-lto2 run %t.bc -r %t.bc,foo,px -r %t.bc,bar, -o %t2
; RUN: llvm-nm %t2.1 | FileCheck %s ; RUN: llvm-nm %t2.1 | FileCheck %s
; CHECK: U bar ; CHECK: U bar
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void ()* @foo() { define void ()* @foo() {
ret void ()* @bar ret void ()* @bar
} }
define available_externally void @bar() { define available_externally void @bar() {
ret void ret void
} }

llvm/test/LTO/Resolution/X86/cache-dso-local.ll

; Tests whether the cache is sensitive to the dso-local bit on referenced ; Tests whether the cache is sensitive to the dso-local bit on referenced
; globals. ; globals.
; RUN: rm -rf %t.cache ; RUN: rm -rf %t.cache
; RUN: opt -module-hash -module-summary -o %t.bc %s ; RUN: opt -module-hash -module-summary -o %t.bc %s
; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache \ ; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache \
; RUN: -r %t.bc,foo,px \ ; RUN: -r %t.bc,foo,px \
; RUN: -r %t.bc,bar,px ; RUN: -r %t.bc,bar,px
; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache \ ; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache \
; RUN: -r %t.bc,foo,plx \ ; RUN: -r %t.bc,foo,plx \
; RUN: -r %t.bc,bar,px ; RUN: -r %t.bc,bar,px
; RUN: ls %t.cache | count 2 ; RUN: ls %t.cache | count 2
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define weak void @foo() { define weak void @foo() {
ret void ret void
} }
define weak void()* @bar() { define weak void()* @bar() {
ret void()* @foo ret void()* @foo
} }

llvm/test/LTO/Resolution/X86/cache-dso-local2.ll

; Tests whether the cache is sensitive to the dso-local bit on called ; Tests whether the cache is sensitive to the dso-local bit on called
; functions. ; functions.
; RUN: rm -rf %t.cache ; RUN: rm -rf %t.cache
; RUN: opt -module-hash -module-summary -o %t.bc %s ; RUN: opt -module-hash -module-summary -o %t.bc %s
; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache \ ; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache \
; RUN: -r %t.bc,foo,px \ ; RUN: -r %t.bc,foo,px \
; RUN: -r %t.bc,bar,px ; RUN: -r %t.bc,bar,px
; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache \ ; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache \
; RUN: -r %t.bc,foo,plx \ ; RUN: -r %t.bc,foo,plx \
; RUN: -r %t.bc,bar,px ; RUN: -r %t.bc,bar,px
; RUN: ls %t.cache | count 2 ; RUN: ls %t.cache | count 2
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define weak void @foo() { define weak void @foo() {
ret void ret void
} }
define weak void @bar() { define weak void @bar() {
call void @foo() call void @foo()
ret void ret void
} }

llvm/test/LTO/Resolution/X86/cache-prevailing.ll

; Tests whether the cache is sensitive to the prevailing bit. ; Tests whether the cache is sensitive to the prevailing bit.
; RUN: rm -rf %t.cache ; RUN: rm -rf %t.cache
; RUN: opt -module-hash -module-summary -o %t.bc %s ; RUN: opt -module-hash -module-summary -o %t.bc %s
; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache \ ; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache \
; RUN: -r %t.bc,foo,p -r %t.bc,bar,px ; RUN: -r %t.bc,foo,p -r %t.bc,bar,px
; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache \ ; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache \
; RUN: -r %t.bc,foo, -r %t.bc,bar,px ; RUN: -r %t.bc,foo, -r %t.bc,bar,px
; RUN: ls %t.cache | count 2 ; RUN: ls %t.cache | count 2
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.11.0" target triple = "x86_64-pc-windows-msvc19.11.0"
@foo = linkonce constant i32 1, comdat @foo = linkonce constant i32 1, comdat
$foo = comdat any $foo = comdat any
define i32* @bar() { define i32* @bar() {
ret i32* @foo ret i32* @foo
} }

llvm/test/LTO/Resolution/X86/comdat-mixed-lto.ll

Show All 15 Lines
; have linker multiply defined errors as it is no longer in a comdat and ; have linker multiply defined errors as it is no longer in a comdat and
; would clash with the copy from this module. ; would clash with the copy from this module.
; RUN: llvm-dis %t3.0.0.preopt.bc -o - | FileCheck %s ; RUN: llvm-dis %t3.0.0.preopt.bc -o - | FileCheck %s
; CHECK: define internal void @__cxx_global_var_init() section ".text.startup" { ; CHECK: define internal void @__cxx_global_var_init() section ".text.startup" {
; CHECK: define available_externally dso_local void @testglobfunc() section ".text.startup" { ; CHECK: define available_externally dso_local void @testglobfunc() section ".text.startup" {
; ModuleID = 'comdat-mixed-lto.o' ; ModuleID = 'comdat-mixed-lto.o'
source_filename = "comdat-mixed-lto.cpp" source_filename = "comdat-mixed-lto.cpp"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
%"class.Test::ptr" = type { i32 } %"class.Test::ptr" = type { i32 }
$C = comdat any $C = comdat any
@C = linkonce_odr global %"class.Test::ptr" zeroinitializer, comdat, align 4 @C = linkonce_odr global %"class.Test::ptr" zeroinitializer, comdat, align 4
@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @__cxx_global_var_init, i8* bitcast (%"class.Test::ptr"* @C to i8*) }] @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @__cxx_global_var_init, i8* bitcast (%"class.Test::ptr"* @C to i8*) }]
Show All 10 Lines

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

Show All 16 Lines
; RUN: -r=%t2.o,r22,px \ ; RUN: -r=%t2.o,r22,px \
; RUN: -r=%t2.o,a21,px \ ; RUN: -r=%t2.o,a21,px \
; RUN: -r=%t2.o,a22,px \ ; RUN: -r=%t2.o,a22,px \
; RUN: -r=%t2.o,a23,px \ ; RUN: -r=%t2.o,a23,px \
; RUN: -r=%t2.o,a24,px \ ; RUN: -r=%t2.o,a24,px \
; RUN: -r=%t2.o,a25,px ; RUN: -r=%t2.o,a25,px
; RUN: llvm-dis %t3.o.0.2.internalize.bc -o - | FileCheck %s ; RUN: llvm-dis %t3.o.0.2.internalize.bc -o - | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
$c1 = comdat any $c1 = comdat any
@v1 = weak_odr global i32 42, comdat($c1) @v1 = weak_odr global i32 42, comdat($c1)
define weak_odr i32 @f1(i8*) comdat($c1) { define weak_odr i32 @f1(i8*) comdat($c1) {
bb10: bb10:
br label %bb11 br label %bb11
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
; Same as before, but reversing the order of the inputs ; Same as before, but reversing the order of the inputs
; RUN: llvm-lto2 run %t2.bc %t1.bc -o %t.o -save-temps \ ; RUN: llvm-lto2 run %t2.bc %t1.bc -o %t.o -save-temps \
; RUN: -r %t1.bc,v,x \ ; RUN: -r %t1.bc,v,x \
; RUN: -r %t2.bc,v,x \ ; RUN: -r %t2.bc,v,x \
; RUN: -r %t1.bc,foo,px \ ; RUN: -r %t1.bc,foo,px \
; RUN: -r %t2.bc,bar,px ; RUN: -r %t2.bc,bar,px
; RUN: llvm-dis < %t.o.0.0.preopt.bc | FileCheck %s --check-prefix=NONE-PREVAILED2 ; RUN: llvm-dis < %t.o.0.0.preopt.bc | FileCheck %s --check-prefix=NONE-PREVAILED2
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@v = common global i8 0, align 8 @v = common global i8 0, align 8
; LARGE-PREVAILED: @v = common global i16 0, align 8 ; LARGE-PREVAILED: @v = common global i16 0, align 8
; SMALL-PREVAILED: @v = common global [2 x i8] zeroinitializer, align 8 ; SMALL-PREVAILED: @v = common global [2 x i8] zeroinitializer, align 8
; BOTH-PREVAILED1: @v = common global i16 0, align 8 ; BOTH-PREVAILED1: @v = common global i16 0, align 8
; BOTH-PREVAILED2: common global [2 x i8] zeroinitializer, align 8 ; BOTH-PREVAILED2: common global [2 x i8] zeroinitializer, align 8
; In this case the first is kept as external ; In this case the first is kept as external
; NONE-PREVAILED1: @v = external global i8, align 8 ; NONE-PREVAILED1: @v = external global i8, align 8
; NONE-PREVAILED2: @v = external global i16, align 4 ; NONE-PREVAILED2: @v = external global i16, align 4
define i8 *@foo() { define i8 *@foo() {
ret i8 *@v ret i8 *@v
} }

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

; RUN: llvm-as -o %t1.bc %s ; RUN: llvm-as -o %t1.bc %s
; RUN: llvm-as -o %t2.bc %p/Inputs/commons.ll ; RUN: llvm-as -o %t2.bc %p/Inputs/commons.ll
; RUN: llvm-lto2 run %t1.bc -r=%t1.bc,x,l %t2.bc -r=%t2.bc,x,pl -o %t.out -save-temps ; RUN: llvm-lto2 run %t1.bc -r=%t1.bc,x,l %t2.bc -r=%t2.bc,x,pl -o %t.out -save-temps
; RUN: llvm-dis -o - %t.out.0.0.preopt.bc | FileCheck %s ; RUN: llvm-dis -o - %t.out.0.0.preopt.bc | FileCheck %s
; A strong definition should override the common ; A strong definition should override the common
; CHECK: @x = dso_local global i32 42, align 4 ; CHECK: @x = dso_local global i32 42, align 4
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@x = common global i16 0, align 2 @x = common global i16 0, align 2

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

; RUN: opt -module-summary -o %t %s ; RUN: opt -module-summary -o %t %s
; RUN: opt -module-summary -o %t2 %S/Inputs/dead-strip-alias.ll ; RUN: opt -module-summary -o %t2 %S/Inputs/dead-strip-alias.ll
; RUN: llvm-lto2 run %t -r %t,main,px -r %t,alias,p -r %t,external, \ ; RUN: llvm-lto2 run %t -r %t,main,px -r %t,alias,p -r %t,external, \
; RUN: %t2 -r %t2,external,p \ ; RUN: %t2 -r %t2,external,p \
; RUN: -save-temps -o %t3 ; RUN: -save-temps -o %t3
; RUN: llvm-nm %t3.2 | FileCheck %s ; RUN: llvm-nm %t3.2 | FileCheck %s
; CHECK: D external ; CHECK: D external
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@alias = alias i8*, i8** @internal @alias = alias i8*, i8** @internal
@internal = internal global i8* @external @internal = internal global i8* @external
@external = external global i8 @external = external global i8
define i8** @main() { define i8** @main() {
ret i8** @alias ret i8** @alias
} }

llvm/test/LTO/Resolution/X86/dead-strip-fulllto.ll

Show All 17 Lines
; FULL: T live2 ; FULL: T live2
; FULL: T main ; FULL: T main
; THIN-NOT: dead ; THIN-NOT: dead
; THIN: T live1 ; THIN: T live1
; THIN: U live2 ; THIN: U live2
; THIN-NOT: odr ; THIN-NOT: odr
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @main() { define void @main() {
call void @live1() call void @live1()
ret void ret void
} }
declare void @live1() declare void @live1()
Show All 11 Lines

llvm/test/LTO/Resolution/X86/diagnostic-handler-remarks-with-hotness.ll

Show All 29 Lines
; YAML-NEXT: - Cost: '-15000' ; YAML-NEXT: - Cost: '-15000'
; YAML-NEXT: - String: ', threshold=' ; YAML-NEXT: - String: ', threshold='
; YAML-NEXT: - Threshold: '337' ; YAML-NEXT: - Threshold: '337'
; YAML-NEXT: - String: ')' ; YAML-NEXT: - String: ')'
; YAML-NEXT: ... ; YAML-NEXT: ...
; CHECK: tinkywinky inlined into main with (cost=-15000, threshold=337) (hotness: 300) ; CHECK: tinkywinky inlined into main with (cost=-15000, threshold=337) (hotness: 300)
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-scei-ps4" target triple = "x86_64-scei-ps4"
declare i32 @patatino() declare i32 @patatino()
define i32 @tinkywinky() { define i32 @tinkywinky() {
%a = call i32 @patatino() %a = call i32 @patatino()
ret i32 %a ret i32 %a
} }
define i32 @main() !prof !0 { define i32 @main() !prof !0 {
%i = call i32 @tinkywinky() %i = call i32 @tinkywinky()
ret i32 %i ret i32 %i
} }
!0 = !{!"function_entry_count", i64 300} !0 = !{!"function_entry_count", i64 300}

llvm/test/LTO/Resolution/X86/diagnostic-handler-remarks.ll

Show All 30 Lines
; YAML-NEXT: - String: ' with ' ; YAML-NEXT: - String: ' with '
; YAML-NEXT: - String: '(cost=' ; YAML-NEXT: - String: '(cost='
; YAML-NEXT: - Cost: '-15000' ; YAML-NEXT: - Cost: '-15000'
; YAML-NEXT: - String: ', threshold=' ; YAML-NEXT: - String: ', threshold='
; YAML-NEXT: - Threshold: '337' ; YAML-NEXT: - Threshold: '337'
; YAML-NEXT: - String: ')' ; YAML-NEXT: - String: ')'
; YAML-NEXT: ... ; YAML-NEXT: ...
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-scei-ps4" target triple = "x86_64-scei-ps4"
declare i32 @patatino() declare i32 @patatino()
define i32 @tinkywinky() { define i32 @tinkywinky() {
%a = call i32 @patatino() %a = call i32 @patatino()
ret i32 %a ret i32 %a
} }
define i32 @main() { define i32 @main() {
%i = call i32 @tinkywinky() %i = call i32 @tinkywinky()
ret i32 %i ret i32 %i
} }

llvm/test/LTO/Resolution/X86/export-jumptable.ll

; Test that we do not internalize functions that appear in the CFI jump table in ; Test that we do not internalize functions that appear in the CFI jump table in
; the full LTO object file; any such functions will be referenced by the jump ; the full LTO object file; any such functions will be referenced by the jump
; table. ; table.
; RUN: opt -thinlto-bc -thinlto-split-lto-unit -o %t %s ; RUN: opt -thinlto-bc -thinlto-split-lto-unit -o %t %s
; RUN: llvm-lto2 run -o %t2 -r %t,f1,p -r %t,f2,p -r %t,_start,px %t -save-temps ; RUN: llvm-lto2 run -o %t2 -r %t,f1,p -r %t,f2,p -r %t,_start,px %t -save-temps
; RUN: llvm-dis %t2.1.2.internalize.bc -o - | FileCheck %s ; RUN: llvm-dis %t2.1.2.internalize.bc -o - | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; CHECK: define void @f1() ; CHECK: define void @f1()
define void @f1() !type !0 { define void @f1() !type !0 {
ret void ret void
} }
; CHECK: define internal void @f2() ; CHECK: define internal void @f2()
Show All 15 Lines

llvm/test/LTO/Resolution/X86/function-alias-non-prevailing.ll

; RUN: llvm-as -o %t %s ; RUN: llvm-as -o %t %s
; RUN: llvm-lto2 run %t -r %t,foo, -r %t,baz,p -o %t2 -save-temps ; RUN: llvm-lto2 run %t -r %t,foo, -r %t,baz,p -o %t2 -save-temps
; RUN: llvm-dis -o - %t2.0.0.preopt.bc | FileCheck %s ; RUN: llvm-dis -o - %t2.0.0.preopt.bc | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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--fuchsia" target triple = "x86_64--fuchsia"
; CHECK: declare void @foo() ; CHECK: declare void @foo()
@foo = weak alias void(), void()* @bar @foo = weak alias void(), void()* @bar
define internal void @bar() { define internal void @bar() {
ret void ret void
} }
define void()* @baz() { define void()* @baz() {
ret void()* @foo ret void()* @foo
} }

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

; RUN: opt -module-summary -o %t.bc %s ; RUN: opt -module-summary -o %t.bc %s
; RUN: llvm-lto2 run %t.bc -r %t.bc,foo,pl -o %t2 ; RUN: llvm-lto2 run %t.bc -r %t.bc,foo,pl -o %t2
; RUN: llvm-nm %t2.1 | FileCheck %s ; RUN: llvm-nm %t2.1 | FileCheck %s
; CHECK: T foo ; CHECK: T foo
; CHECK: t foo_ifunc ; CHECK: t foo_ifunc
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foo = ifunc i32 (i32), i64 ()* @foo_ifunc @foo = ifunc i32 (i32), i64 ()* @foo_ifunc
define internal i64 @foo_ifunc() { define internal i64 @foo_ifunc() {
entry: entry:
ret i64 0 ret i64 0
} }

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

; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: llvm-as %p/Inputs/intrinsic.ll -o %t2.o ; RUN: llvm-as %p/Inputs/intrinsic.ll -o %t2.o
; RUN: llvm-lto2 run -o %t3.o %t1.o %t2.o -r %t1.o,foo ; RUN: llvm-lto2 run -o %t3.o %t1.o %t2.o -r %t1.o,foo
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
%foo = type { } %foo = type { }
declare void @foo( %foo* ) declare void @foo( %foo* )

llvm/test/LTO/Resolution/X86/link-odr-availextern.ll

Show All 20 Lines
; RUN: llvm-dis < %t3.0.0.preopt.bc -o - | FileCheck --check-prefix=NONPREVAILING %s ; RUN: llvm-dis < %t3.0.0.preopt.bc -o - | FileCheck --check-prefix=NONPREVAILING %s
; RUN: llvm-lto2 run -o %t3 %t2odr -r %t2odr,f, -save-temps ; RUN: llvm-lto2 run -o %t3 %t2odr -r %t2odr,f, -save-temps
; RUN: llvm-dis < %t3.0.0.preopt.bc -o - | FileCheck --check-prefix=NONPREVAILING %s ; RUN: llvm-dis < %t3.0.0.preopt.bc -o - | FileCheck --check-prefix=NONPREVAILING %s
; RUN: llvm-lto2 run -o %t3 %t2odr %t1 -r %t1,f, -r %t2odr,f, -save-temps ; RUN: llvm-lto2 run -o %t3 %t2odr %t1 -r %t1,f, -r %t2odr,f, -save-temps
; RUN: llvm-dis < %t3.0.0.preopt.bc -o - | FileCheck --check-prefix=NONPREVAILING %s ; RUN: llvm-dis < %t3.0.0.preopt.bc -o - | FileCheck --check-prefix=NONPREVAILING %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; PREVAILING: define weak_odr i32 @f() ; PREVAILING: define weak_odr i32 @f()
; PREVAILING-NEXT: ret i32 1 ; PREVAILING-NEXT: ret i32 1
; NONPREVAILING: define available_externally i32 @f() ; NONPREVAILING: define available_externally i32 @f()
; NONPREVAILING-NEXT: ret i32 2 ; NONPREVAILING-NEXT: ret i32 2
define linkonce_odr i32 @f() { define linkonce_odr i32 @f() {
ret i32 1 ret i32 1
} }

llvm/test/LTO/Resolution/X86/linker-redef-thin.ll

; RUN: opt -module-summary %s -o %t.o ; RUN: opt -module-summary %s -o %t.o
; RUN: llvm-lto2 run -o %t1.o %t.o -r %t.o,patatino,pr ; RUN: llvm-lto2 run -o %t1.o %t.o -r %t.o,patatino,pr
; RUN: llvm-readobj --symbols %t1.o.1 | FileCheck %s ; RUN: llvm-readobj --symbols %t1.o.1 | FileCheck %s
; CHECK: Name: patatino ; CHECK: Name: patatino
; CHECK-NEXT: Value: ; CHECK-NEXT: Value:
; CHECK-NEXT: Size: ; CHECK-NEXT: Size:
; CHECK-NEXT: Binding: Weak ; CHECK-NEXT: Binding: Weak
; CHECK-NEXT: Type: Function ; CHECK-NEXT: Type: Function
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @patatino() { define void @patatino() {
ret void ret void
} }

llvm/test/LTO/Resolution/X86/linker-redef.ll

; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: llvm-lto2 run -o %t1.o %t.o -r %t.o,bar,pr ; RUN: llvm-lto2 run -o %t1.o %t.o -r %t.o,bar,pr
; RUN: llvm-readobj --symbols %t1.o.0 | FileCheck %s ; RUN: llvm-readobj --symbols %t1.o.0 | FileCheck %s
; CHECK: Name: bar ; CHECK: Name: bar
; CHECK-NEXT: Value: ; CHECK-NEXT: Value:
; CHECK-NEXT: Size: ; CHECK-NEXT: Size:
; CHECK-NEXT: Binding: Weak ; CHECK-NEXT: Binding: Weak
; CHECK-NEXT: Type: Function ; CHECK-NEXT: Type: Function
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @bar() { define void @bar() {
ret void ret void
} }

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

; RUN: opt -module-summary -o %t %s ; RUN: opt -module-summary -o %t %s
; RUN: llvm-lto2 run %t -O0 -r %t,foo,px -o %t2 ; RUN: llvm-lto2 run %t -O0 -r %t,foo,px -o %t2
; RUN: llvm-nm %t2.1 | FileCheck %s ; RUN: llvm-nm %t2.1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; CHECK: W foo ; CHECK: W foo
define linkonce_odr void @foo() { define linkonce_odr void @foo() {
ret void ret void
} }

llvm/test/LTO/Resolution/X86/load-sample-prof-icp.ll

; Test that llvm-lto2 handles the -lto-sample-profile-file option and pass ; Test that llvm-lto2 handles the -lto-sample-profile-file option and pass
; down to the ICP correctly. ; down to the ICP correctly.
; ;
; RUN: opt -module-summary < %s -o %t.bc ; RUN: opt -module-summary < %s -o %t.bc
; RUN: llvm-lto2 run -o %t.out %t.bc -save-temps \ ; RUN: llvm-lto2 run -o %t.out %t.bc -save-temps \
; RUN: -r %t.bc,test,px -r %t.bc,bar,x \ ; RUN: -r %t.bc,test,px -r %t.bc,bar,x \
; RUN: -lto-sample-profile-file=%S/Inputs/load-sample-prof-icp.prof ; RUN: -lto-sample-profile-file=%S/Inputs/load-sample-prof-icp.prof
; RUN: llvm-dis %t.out.1.4.opt.bc -o - | FileCheck %s ; RUN: llvm-dis %t.out.1.4.opt.bc -o - | FileCheck %s
; RUN: llvm-lto2 run -o %t.out %t.bc -save-temps \ ; RUN: llvm-lto2 run -o %t.out %t.bc -save-temps \
; RUN: -r %t.bc,test,px -r %t.bc,bar,x -use-new-pm \ ; RUN: -r %t.bc,test,px -r %t.bc,bar,x -use-new-pm \
; RUN: -lto-sample-profile-file=%S/Inputs/load-sample-prof-icp.prof ; RUN: -lto-sample-profile-file=%S/Inputs/load-sample-prof-icp.prof
; RUN: llvm-dis %t.out.1.4.opt.bc -o - | FileCheck %s ; RUN: llvm-dis %t.out.1.4.opt.bc -o - | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; CHECK-LABEL: @test ; CHECK-LABEL: @test
; Checks that the call instruction is promoted to direct call and has ; Checks that the call instruction is promoted to direct call and has
; profile count annotated on the direct call. ; profile count annotated on the direct call.
define void @test(void ()*) !dbg !7 { define void @test(void ()*) !dbg !7 {
%2 = alloca void ()* %2 = alloca void ()*
store void ()* %0, void ()** %2 store void ()* %0, void ()** %2
Show All 24 Lines

llvm/test/LTO/Resolution/X86/load-sample-prof-lto.ll

Show All 11 Lines
; RUN: llvm-lto2 run -o %t.out %t.bc -save-temps -use-new-pm \ ; RUN: llvm-lto2 run -o %t.out %t.bc -save-temps -use-new-pm \
; RUN: -r %t.bc,foo,px -r %t.bc,bar,x \ ; RUN: -r %t.bc,foo,px -r %t.bc,bar,x \
; RUN: -lto-sample-profile-file=%S/Inputs/load-sample-prof.prof ; RUN: -lto-sample-profile-file=%S/Inputs/load-sample-prof.prof
; RUN: llvm-dis %t.out.0.4.opt.bc -o - | FileCheck %s ; RUN: llvm-dis %t.out.0.4.opt.bc -o - | FileCheck %s
; Make sure profile information is attached. ; Make sure profile information is attached.
; CHECK: !prof ; CHECK: !prof
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @foo() local_unnamed_addr !dbg !7 { define void @foo() local_unnamed_addr !dbg !7 {
entry: entry:
tail call void @bar(), !dbg !10 tail call void @bar(), !dbg !10
ret void, !dbg !11 ret void, !dbg !11
} }
Show All 18 Lines

llvm/test/LTO/Resolution/X86/load-sample-prof.ll

; Test that llvm-lto2 handles the -lto-sample-profile-file option ; Test that llvm-lto2 handles the -lto-sample-profile-file option
; ;
; RUN: opt -module-summary < %s -o %t.bc ; RUN: opt -module-summary < %s -o %t.bc
; RUN: llvm-lto2 run -o %t.out %t.bc -save-temps \ ; RUN: llvm-lto2 run -o %t.out %t.bc -save-temps \
; RUN: -r %t.bc,foo,px -r %t.bc,bar,x \ ; RUN: -r %t.bc,foo,px -r %t.bc,bar,x \
; RUN: -lto-sample-profile-file=%S/Inputs/load-sample-prof.prof ; RUN: -lto-sample-profile-file=%S/Inputs/load-sample-prof.prof
; RUN: llvm-dis %t.out.1.4.opt.bc -o - | FileCheck %s ; RUN: llvm-dis %t.out.1.4.opt.bc -o - | FileCheck %s
; ;
; CHECK: !prof ; CHECK: !prof
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @foo() local_unnamed_addr !dbg !7 { define void @foo() local_unnamed_addr !dbg !7 {
entry: entry:
tail call void @bar(), !dbg !10 tail call void @bar(), !dbg !10
ret void, !dbg !11 ret void, !dbg !11
} }
Show All 18 Lines

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

; RUN: opt -thinlto-bc -thinlto-split-lto-unit -o %t0.bc %s ; RUN: opt -thinlto-bc -thinlto-split-lto-unit -o %t0.bc %s
; RUN: llvm-lto2 run -r %t0.bc,__imp_f,l \ ; RUN: llvm-lto2 run -r %t0.bc,__imp_f,l \
; RUN: -r %t0.bc,g,p \ ; RUN: -r %t0.bc,g,p \
; RUN: -r %t0.bc,g,l \ ; RUN: -r %t0.bc,g,l \
; RUN: -r %t0.bc,e,l \ ; RUN: -r %t0.bc,e,l \
; RUN: -r %t0.bc,main,x \ ; RUN: -r %t0.bc,main,x \
; RUN: -save-temps -o %t1 %t0.bc ; RUN: -save-temps -o %t1 %t0.bc
; RUN: llvm-dis %t1.1.3.import.bc -o - | FileCheck %s ; RUN: llvm-dis %t1.1.3.import.bc -o - | FileCheck %s
source_filename = "test.cpp" source_filename = "test.cpp"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
$g = comdat any $g = comdat any
@g = global i8 42, comdat, !type !0 @g = global i8 42, comdat, !type !0
; CHECK: define ; CHECK: define
; CHECK-NOT: dllimport ; CHECK-NOT: dllimport
; CHECK-SAME: @f ; CHECK-SAME: @f
Show All 14 Lines

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

; RUN: opt -thinlto-bc -thinlto-split-lto-unit -o %t %s ; RUN: opt -thinlto-bc -thinlto-split-lto-unit -o %t %s
; RUN: llvm-lto2 run -r %t,f,plx -r %t,g_alias,plx -r %t,foo,lx -r %t,foo,plx -r %t,bar,lx -r %t,bar,plx -o %t1 %t ; RUN: llvm-lto2 run -r %t,f,plx -r %t,g_alias,plx -r %t,foo,lx -r %t,foo,plx -r %t,bar,lx -r %t,bar,plx -o %t1 %t
; RUN: llvm-nm %t1.0 | FileCheck --check-prefix=MERGED %s ; RUN: llvm-nm %t1.0 | FileCheck --check-prefix=MERGED %s
; RUN: llvm-nm %t1.1 | FileCheck %s ; RUN: llvm-nm %t1.1 | FileCheck %s
; MERGED: R __typeid_bar_global_addr ; MERGED: R __typeid_bar_global_addr
; MERGED: R __typeid_foo_global_addr ; MERGED: R __typeid_foo_global_addr
; CHECK: U __typeid_bar_global_addr ; CHECK: U __typeid_bar_global_addr
; CHECK: U __typeid_foo_global_addr ; CHECK: U __typeid_foo_global_addr
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foo = global i32 0, !type !0 @foo = global i32 0, !type !0
@bar = global i32 0, !type !1 @bar = global i32 0, !type !1
define i1 @f(i8* %ptr) { define i1 @f(i8* %ptr) {
%p = call i1 @llvm.type.test(i8* %ptr, metadata !"foo") %p = call i1 @llvm.type.test(i8* %ptr, metadata !"foo")
ret i1 %p ret i1 %p
Show All 13 Lines

llvm/test/LTO/Resolution/X86/lto-unit-check.ll

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
; with older bitcode where it was always enabled). ; with older bitcode where it was always enabled).
; SPLITLTOUNIT: <FLAGS op0=8/> ; SPLITLTOUNIT: <FLAGS op0=8/>
; NOSPLITLTOUNIT: <FLAGS op0=0/> ; NOSPLITLTOUNIT: <FLAGS op0=0/>
; Check that the corresponding module flag is set when expected. ; Check that the corresponding module flag is set when expected.
; ENABLESPLITFLAG: !{i32 1, !"EnableSplitLTOUnit", i32 1} ; ENABLESPLITFLAG: !{i32 1, !"EnableSplitLTOUnit", i32 1}
; NOENABLESPLITFLAG-NOT: !{i32 1, !"EnableSplitLTOUnit", i32 1} ; NOENABLESPLITFLAG-NOT: !{i32 1, !"EnableSplitLTOUnit", i32 1}
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"

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

Show All 13 Lines
; NM1-DAG: U g ; NM1-DAG: U g
; Do the same test again, but with the regular and thin LTO modules in the same file. ; Do the same test again, but with the regular and thin LTO modules in the same file.
; RUN: llvm-cat -b -o %t4.o %t2.o %t1.o ; RUN: llvm-cat -b -o %t4.o %t2.o %t1.o
; RUN: llvm-lto2 run -o %t5.o %t4.o -r %t4.o,main,px -r %t4.o,g, -r %t4.o,g,px ; RUN: llvm-lto2 run -o %t5.o %t4.o -r %t4.o,main,px -r %t4.o,g, -r %t4.o,g,px
; RUN: llvm-nm %t5.o.0 | FileCheck %s --check-prefix=NM0 ; RUN: llvm-nm %t5.o.0 | FileCheck %s --check-prefix=NM0
; RUN: llvm-nm %t5.o.1 | FileCheck %s --check-prefix=NM1 ; RUN: llvm-nm %t5.o.1 | FileCheck %s --check-prefix=NM1
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i32 @g() { define i32 @g() {
ret i32 0 ret i32 0
} }

llvm/test/LTO/Resolution/X86/mod-asm-used.ll

; RUN: opt -module-summary -o %t.bc %s ; RUN: opt -module-summary -o %t.bc %s
; RUN: opt -module-summary -o %t2.bc %S/Inputs/mod-asm-used.ll ; RUN: opt -module-summary -o %t2.bc %S/Inputs/mod-asm-used.ll
; RUN: llvm-lto2 run %t.bc -r %t.bc,foo,l %t2.bc -r %t2.bc,foo,pl -o %t3 -save-temps ; RUN: llvm-lto2 run %t.bc -r %t.bc,foo,l %t2.bc -r %t2.bc,foo,pl -o %t3 -save-temps
; RUN: llvm-nm %t3.? | FileCheck %s ; RUN: llvm-nm %t3.? | FileCheck %s
; RUN: llvm-dis %t3.index.bc -o - | FileCheck %s --check-prefix=INDEX ; RUN: llvm-dis %t3.index.bc -o - | FileCheck %s --check-prefix=INDEX
; INDEX: ^0 = module: (path: "{{.*}}mod-asm-used.ll.tmp.bc" ; INDEX: ^0 = module: (path: "{{.*}}mod-asm-used.ll.tmp.bc"
; INDEX: ^1 = module: (path: "{{.*}}mod-asm-used.ll.tmp2.bc" ; INDEX: ^1 = module: (path: "{{.*}}mod-asm-used.ll.tmp2.bc"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; CHECK: D foo ; CHECK: D foo
module asm ".quad foo" module asm ".quad foo"

llvm/test/LTO/Resolution/X86/multi-thinlto.ll

; RUN: opt -module-summary %s -o %t.o ; RUN: opt -module-summary %s -o %t.o
; RUN: llvm-cat -b -o %t2.o %t.o %t.o ; RUN: llvm-cat -b -o %t2.o %t.o %t.o
; RUN: not llvm-lto2 run -o %t3.o %t2.o 2>&1 | FileCheck %s ; RUN: not llvm-lto2 run -o %t3.o %t2.o 2>&1 | FileCheck %s
; CHECK: Expected at most one ThinLTO module per bitcode file ; CHECK: Expected at most one ThinLTO module per bitcode file
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"

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

Show All 19 Lines
; CHECK-NEXT: movq (%rip), %rax ; CHECK-NEXT: movq (%rip), %rax
; Check that 'barAlias' and 'varAlias' produced as undefined. ; Check that 'barAlias' and 'varAlias' produced as undefined.
; RUN: llvm-readelf --symbols %t2.o.1 | FileCheck %s --check-prefix=SYMBOLS ; RUN: llvm-readelf --symbols %t2.o.1 | FileCheck %s --check-prefix=SYMBOLS
; SYMBOLS: NOTYPE GLOBAL DEFAULT UND barAlias ; SYMBOLS: NOTYPE GLOBAL DEFAULT UND barAlias
; SYMBOLS: NOTYPE GLOBAL DEFAULT UND varAlias ; SYMBOLS: NOTYPE GLOBAL DEFAULT UND varAlias
; SYMBOLS: FUNC GLOBAL DEFAULT 2 zed ; SYMBOLS: FUNC GLOBAL DEFAULT 2 zed
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@barAlias = alias void(), void()* @bar @barAlias = alias void(), void()* @bar
define void @bar() { define void @bar() {
ret void ret void
} }
@var = global i32 99 @var = global i32 99
@varAlias = alias i32, i32* @var @varAlias = alias i32, i32* @var
define i32 @zed() { define i32 @zed() {
call void @barAlias() call void @barAlias()
%1 = load i32, i32* @varAlias, align 4 %1 = load i32, i32* @varAlias, align 4
ret i32 %1 ret i32 %1
} }

llvm/test/LTO/Resolution/X86/not-prevailing-variables.ll

Show All 13 Lines
; CHECK: testVar2: ; CHECK: testVar2:
; CHECK-NEXT: movl (%rip), %eax ; CHECK-NEXT: movl (%rip), %eax
; CHECK-NEXT: retq ; CHECK-NEXT: retq
; Check 'var2' is undefined. ; Check 'var2' is undefined.
; RUN: llvm-readelf --symbols %t2.o.1 | FileCheck %s --check-prefix=UND ; RUN: llvm-readelf --symbols %t2.o.1 | FileCheck %s --check-prefix=UND
; UND: NOTYPE GLOBAL DEFAULT UND var2 ; UND: NOTYPE GLOBAL DEFAULT UND var2
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@var1 = global i32 10, align 4 @var1 = global i32 10, align 4
define i32 @testVar1() { define i32 @testVar1() {
%1 = load i32, i32* @var1, align 4 %1 = load i32, i32* @var1, align 4
ret i32 %1 ret i32 %1
} }
@var2 = global i32 11, align 4 @var2 = global i32 11, align 4
define i32 @testVar2() { define i32 @testVar2() {
%1 = load i32, i32* @var2, align 4 %1 = load i32, i32* @var2, align 4
ret i32 %1 ret i32 %1
} }

llvm/test/LTO/Resolution/X86/not-prevailing.ll

Show All 15 Lines
; RUN: llvm-objdump -d %t3.o.1 | FileCheck %s ; RUN: llvm-objdump -d %t3.o.1 | FileCheck %s
; RUN: llvm-readelf --symbols %t3.o.1 | FileCheck %s --check-prefix=SYMBOLS ; RUN: llvm-readelf --symbols %t3.o.1 | FileCheck %s --check-prefix=SYMBOLS
; Check that 'foo' and 'bar' produced as undefined. ; Check that 'foo' and 'bar' produced as undefined.
; SYMBOLS: NOTYPE GLOBAL DEFAULT UND bar ; SYMBOLS: NOTYPE GLOBAL DEFAULT UND bar
; SYMBOLS: NOTYPE GLOBAL DEFAULT UND foo ; SYMBOLS: NOTYPE GLOBAL DEFAULT UND foo
; SYMBOLS: FUNC GLOBAL DEFAULT 2 zed ; SYMBOLS: FUNC GLOBAL DEFAULT 2 zed
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
$foo = comdat any $foo = comdat any
define weak i32 @foo() comdat { define weak i32 @foo() comdat {
ret i32 65 ret i32 65
} }
declare void @bar() declare void @bar()
define i32 @zed() { define i32 @zed() {
%1 = tail call i32 @foo() %1 = tail call i32 @foo()
call void @bar() call void @bar()
ret i32 %1 ret i32 %1
} }

llvm/test/LTO/Resolution/X86/setting-dso-local.ll

; RUN: llvm-as -o %t.o %s ; RUN: llvm-as -o %t.o %s
; RUN: llvm-lto2 run -o %t2.o %t.o -r=%t.o,_start,plx -r=%t.o,foobar,x ; RUN: llvm-lto2 run -o %t2.o %t.o -r=%t.o,_start,plx -r=%t.o,foobar,x
; RUN: llvm-readelf --symbols %t2.o.0 | FileCheck %s ; RUN: llvm-readelf --symbols %t2.o.0 | FileCheck %s
; We used to fail the verifier by clearing dso_local from foobar ; We used to fail the verifier by clearing dso_local from foobar
; CHECK: 0000000000000000 0 NOTYPE GLOBAL HIDDEN UND foobar ; CHECK: 0000000000000000 0 NOTYPE GLOBAL HIDDEN UND foobar
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foobar = external hidden global i32 @foobar = external hidden global i32
define i32* @_start() { define i32* @_start() {
ret i32* @foobar ret i32* @foobar
} }

llvm/test/LTO/Resolution/X86/symtab-elf.ll

; RUN: llvm-as -o %t %s ; RUN: llvm-as -o %t %s
; RUN: llvm-lto2 dump-symtab %t | FileCheck %s ; RUN: llvm-lto2 dump-symtab %t | FileCheck %s
; CHECK: target triple: x86_64-unknown-linux-gnu ; CHECK: target triple: x86_64-unknown-linux-gnu
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
; CHECK-NOT: linker opts: ; CHECK-NOT: linker opts:
!0 = !{!"/include:foo"} !0 = !{!"/include:foo"}
!llvm.linker.options = !{ !0 } !llvm.linker.options = !{ !0 }
; CHECK: {{^dependent libraries: \"foo\" \"b a r\" \"baz\"$}} ; CHECK: {{^dependent libraries: \"foo\" \"b a r\" \"baz\"$}}
!1 = !{!"foo"} !1 = !{!"foo"}
!2 = !{!"b a r"} !2 = !{!"b a r"}
!3 = !{!"baz"} !3 = !{!"baz"}
!llvm.dependent-libraries = !{!1, !2, !3} !llvm.dependent-libraries = !{!1, !2, !3}
@g1 = global i32 0 @g1 = global i32 0
; CHECK-NOT: fallback g1 ; CHECK-NOT: fallback g1
@g2 = weak alias i32, i32* @g1 @g2 = weak alias i32, i32* @g1

llvm/test/LTO/Resolution/X86/type-checked-load.ll

; RUN: llvm-as -o %t %s ; RUN: llvm-as -o %t %s
; RUN: llvm-lto2 run %t -O0 -r %t,foo,px -o %t2 ; RUN: llvm-lto2 run %t -O0 -r %t,foo,px -o %t2
; This just tests that we don't crash when compiling this test case. ; This just tests that we don't crash when compiling this test case.
; It means that the wholeprogramdevirt pass must have run and lowered ; It means that the wholeprogramdevirt pass must have run and lowered
; the llvm.type.checked.load call. ; the llvm.type.checked.load call.
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define {i8*, i1} @foo(i8* %ptr) { define {i8*, i1} @foo(i8* %ptr) {
%pair = call {i8*, i1} @llvm.type.checked.load(i8* %ptr, i32 16, metadata !"foo") %pair = call {i8*, i1} @llvm.type.checked.load(i8* %ptr, i32 16, metadata !"foo")
ret {i8*, i1} %pair ret {i8*, i1} %pair
} }
declare {i8*, i1} @llvm.type.checked.load(i8* %ptr, i32 %offset, metadata %type) declare {i8*, i1} @llvm.type.checked.load(i8* %ptr, i32 %offset, metadata %type)

llvm/test/LTO/X86/Inputs/codemodel-3.ll

target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
!llvm.module.flags = !{!0, !1} !llvm.module.flags = !{!0, !1}
!0 = !{i32 1, !"wchar_size", i32 4} !0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 1, !"Code Model", i32 1} !1 = !{i32 1, !"Code Model", i32 1}
%struct.rtx_def = type { i16, i16 } %struct.rtx_def = type { i16, i16 }
define void @bar(%struct.rtx_def* %a, i8 %b, i32 %c) { define void @bar(%struct.rtx_def* %a, i8 %b, i32 %c) {
call void @llvm.memset.p0struct.rtx_def.i32(%struct.rtx_def* align 4 %a, i8 %b, i32 %c, i1 true) call void @llvm.memset.p0struct.rtx_def.i32(%struct.rtx_def* align 4 %a, i8 %b, i32 %c, i1 true)
ret void ret void
} }
declare void @llvm.memset.p0struct.rtx_def.i32(%struct.rtx_def*, i8, i32, i1) declare void @llvm.memset.p0struct.rtx_def.i32(%struct.rtx_def*, i8, i32, i1)

llvm/test/LTO/X86/Inputs/dllimport.ll

; ModuleID = 'b.obj' ; ModuleID = 'b.obj'
source_filename = "b.cpp" source_filename = "b.cpp"
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.11.0" target triple = "x86_64-pc-windows-msvc19.11.0"
; Function Attrs: norecurse nounwind readnone sspstrong uwtable ; Function Attrs: norecurse nounwind readnone sspstrong uwtable
define dso_local i32 @"?foo@@YAHXZ"() local_unnamed_addr { define dso_local i32 @"?foo@@YAHXZ"() local_unnamed_addr {
entry: entry:
ret i32 42 ret i32 42
} }
!llvm.module.flags = !{!1} !llvm.module.flags = !{!1}
!1 = !{i32 1, !"ThinLTO", i32 0} !1 = !{i32 1, !"ThinLTO", i32 0}
^0 = module: (path: "b.obj", hash: (0, 0, 0, 0, 0)) ^0 = module: (path: "b.obj", hash: (0, 0, 0, 0, 0))
^1 = gv: (name: "?foo@@YAHXZ", summaries: (function: (module: ^0, flags: (linkage: external, notEligibleToImport: 1, live: 0, dsoLocal: 1), insts: 1, funcFlags: (readNone: 1, readOnly: 0, noRecurse: 1, returnDoesNotAlias: 0)))) ; guid = 2709792123250749187 ^1 = gv: (name: "?foo@@YAHXZ", summaries: (function: (module: ^0, flags: (linkage: external, notEligibleToImport: 1, live: 0, dsoLocal: 1), insts: 1, funcFlags: (readNone: 1, readOnly: 0, noRecurse: 1, returnDoesNotAlias: 0)))) ; guid = 2709792123250749187

llvm/test/LTO/X86/Inputs/remangle_intrinsics_tbaa.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
%some_named_struct = type { i8, i8 } %some_named_struct = type { i8, i8 }
define void @bar(%some_named_struct*) { define void @bar(%some_named_struct*) {
ret void ret void
} }

llvm/test/LTO/X86/Inputs/strip-debug-info-bar.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.12" target triple = "x86_64-apple-macosx10.12"
define void @bar() !dbg !3 { define void @bar() !dbg !3 {
ret void ret void
} }
!llvm.module.flags = !{!0} !llvm.module.flags = !{!0}
!llvm.dbg.cu = !{!1} !llvm.dbg.cu = !{!1}
!0 = !{i32 2, !"Debug Info Version", i32 3} !0 = !{i32 2, !"Debug Info Version", i32 3}
!1 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2) !1 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2)
!2 = !DIFile(filename: "broken", directory: "") !2 = !DIFile(filename: "broken", directory: "")
!3 = distinct !DISubprogram(line: 1000, isDefinition: true) !3 = distinct !DISubprogram(line: 1000, isDefinition: true)

llvm/test/LTO/X86/Inputs/type-mapping-bug2.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i32 @c() !dbg !6 { define i32 @c() !dbg !6 {
unreachable unreachable
} }
!llvm.module.flags = !{!0, !1} !llvm.module.flags = !{!0, !1}
!llvm.dbg.cu = !{!2} !llvm.dbg.cu = !{!2}
!0 = !{i32 2, !"Debug Info Version", i32 3} !0 = !{i32 2, !"Debug Info Version", i32 3}
!1 = !{i32 1, !"ThinLTO", i32 0} !1 = !{i32 1, !"ThinLTO", i32 0}
!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, retainedTypes: !4) !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, retainedTypes: !4)
!3 = !DIFile(filename: "f2", directory: "") !3 = !DIFile(filename: "f2", directory: "")
!4 = !{!5} !4 = !{!5}
!5 = !DICompositeType(tag: DW_TAG_class_type, file: !3, flags: DIFlagFwdDecl, identifier: "SHARED") !5 = !DICompositeType(tag: DW_TAG_class_type, file: !3, flags: DIFlagFwdDecl, identifier: "SHARED")
!6 = distinct !DISubprogram(unit: !2) !6 = distinct !DISubprogram(unit: !2)

llvm/test/LTO/X86/codemodel-1.ll

; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: llvm-lto2 run -r %t.o,_start,px %t.o -o %t.s ; RUN: llvm-lto2 run -r %t.o,_start,px %t.o -o %t.s
; RUN: llvm-objdump -d %t.s.0 | FileCheck %s --check-prefix=CHECK-SMALL ; RUN: llvm-objdump -d %t.s.0 | FileCheck %s --check-prefix=CHECK-SMALL
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
!llvm.module.flags = !{!0, !1} !llvm.module.flags = !{!0, !1}
!0 = !{i32 1, !"wchar_size", i32 4} !0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 1, !"Code Model", i32 1} !1 = !{i32 1, !"Code Model", i32 1}
@data = internal constant [0 x i32] [] @data = internal constant [0 x i32] []
define i32* @_start() nounwind readonly { define i32* @_start() nounwind readonly {
entry: entry:
; CHECK-SMALL-LABEL: _start: ; CHECK-SMALL-LABEL: _start:
; CHECK-SMALL: leaq (%rip), %rax ; CHECK-SMALL: leaq (%rip), %rax
ret i32* getelementptr ([0 x i32], [0 x i32]* @data, i64 0, i64 0) ret i32* getelementptr ([0 x i32], [0 x i32]* @data, i64 0, i64 0)
} }

llvm/test/LTO/X86/codemodel-2.ll

; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: llvm-lto2 run -r %t.o,_start,px %t.o -o %t.s ; RUN: llvm-lto2 run -r %t.o,_start,px %t.o -o %t.s
; RUN: llvm-objdump -d %t.s.0 | FileCheck %s --check-prefix=CHECK-LARGE ; RUN: llvm-objdump -d %t.s.0 | FileCheck %s --check-prefix=CHECK-LARGE
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
!llvm.module.flags = !{!0, !1} !llvm.module.flags = !{!0, !1}
!0 = !{i32 1, !"wchar_size", i32 4} !0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 1, !"Code Model", i32 4} !1 = !{i32 1, !"Code Model", i32 4}
@data = internal constant [0 x i32] [] @data = internal constant [0 x i32] []
define i32* @_start() nounwind readonly { define i32* @_start() nounwind readonly {
entry: entry:
; CHECK-LARGE-LABEL: _start: ; CHECK-LARGE-LABEL: _start:
; CHECK-LARGE: movabsq $0, %rax ; CHECK-LARGE: movabsq $0, %rax
ret i32* getelementptr ([0 x i32], [0 x i32]* @data, i64 0, i64 0) ret i32* getelementptr ([0 x i32], [0 x i32]* @data, i64 0, i64 0)
} }

llvm/test/LTO/X86/codemodel-3.ll

; RUN: llvm-as %s -o %t0.o ; RUN: llvm-as %s -o %t0.o
; RUN: llvm-as < %p/Inputs/codemodel-3.ll > %t1.o ; RUN: llvm-as < %p/Inputs/codemodel-3.ll > %t1.o
; RUN: not llvm-lto2 run -r %t0.o,_start,px -r %t1.o,bar,px %t0.o %t1.o -o %t2.s 2>&1 | FileCheck %s ; RUN: not llvm-lto2 run -r %t0.o,_start,px -r %t1.o,bar,px %t0.o %t1.o -o %t2.s 2>&1 | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
!llvm.module.flags = !{!0, !1} !llvm.module.flags = !{!0, !1}
!0 = !{i32 1, !"wchar_size", i32 4} !0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 1, !"Code Model", i32 4} !1 = !{i32 1, !"Code Model", i32 4}
@data = internal constant [0 x i32] [] @data = internal constant [0 x i32] []
define i32* @_start() nounwind readonly { define i32* @_start() nounwind readonly {
entry: entry:
ret i32* getelementptr ([0 x i32], [0 x i32]* @data, i64 0, i64 0) ret i32* getelementptr ([0 x i32], [0 x i32]* @data, i64 0, i64 0)
} }
; CHECK: 'Code Model': IDs have conflicting values ; CHECK: 'Code Model': IDs have conflicting values

llvm/test/LTO/X86/current-section.ll

; RUN: llvm-as < %s >%t1 ; RUN: llvm-as < %s >%t1
; RUN: llvm-lto -o %t2 %t1 ; RUN: llvm-lto -o %t2 %t1
; REQUIRES: default_triple ; REQUIRES: default_triple
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
module asm ".align 4" module asm ".align 4"

llvm/test/LTO/X86/diagnostic-handler-remarks-with-hotness.ll

Show All 19 Lines
; YAML-NEXT: - String: ' with ' ; YAML-NEXT: - String: ' with '
; YAML-NEXT: - String: '(cost=' ; YAML-NEXT: - String: '(cost='
; YAML-NEXT: - Cost: '-15000' ; YAML-NEXT: - Cost: '-15000'
; YAML-NEXT: - String: ', threshold=' ; YAML-NEXT: - String: ', threshold='
; YAML-NEXT: - Threshold: '337' ; YAML-NEXT: - Threshold: '337'
; YAML-NEXT: - String: ')' ; YAML-NEXT: - String: ')'
; YAML-NEXT: ... ; YAML-NEXT: ...
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-darwin" target triple = "x86_64-apple-darwin"
declare i32 @bar() declare i32 @bar()
define i32 @foo() { define i32 @foo() {
%a = call i32 @bar() %a = call i32 @bar()
ret i32 %a ret i32 %a
} }
define i32 @main() !prof !0 { define i32 @main() !prof !0 {
%i = call i32 @foo() %i = call i32 @foo()
ret i32 %i ret i32 %i
} }
!0 = !{!"function_entry_count", i64 300} !0 = !{!"function_entry_count", i64 300}

llvm/test/LTO/X86/diagnostic-handler-remarks.ll

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
; YAML-NEXT: - String: ' with ' ; YAML-NEXT: - String: ' with '
; YAML-NEXT: - String: '(cost=' ; YAML-NEXT: - String: '(cost='
; YAML-NEXT: - Cost: '-15000' ; YAML-NEXT: - Cost: '-15000'
; YAML-NEXT: - String: ', threshold=' ; YAML-NEXT: - String: ', threshold='
; YAML-NEXT: - Threshold: '337' ; YAML-NEXT: - Threshold: '337'
; YAML-NEXT: - String: ')' ; YAML-NEXT: - String: ')'
; YAML-NEXT: ... ; YAML-NEXT: ...
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-darwin" target triple = "x86_64-apple-darwin"
declare i32 @bar() declare i32 @bar()
define i32 @foo() { define i32 @foo() {
%a = call i32 @bar() %a = call i32 @bar()
ret i32 %a ret i32 %a
} }
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

llvm/test/LTO/X86/disable-verify.ll

; RUN: llvm-as < %s >%t.bc ; RUN: llvm-as < %s >%t.bc
; RUN: llvm-lto -debug-pass=Arguments -exported-symbol=_f -o /dev/null %t.bc 2>&1 -disable-verify | FileCheck %s ; RUN: llvm-lto -debug-pass=Arguments -exported-symbol=_f -o /dev/null %t.bc 2>&1 -disable-verify | FileCheck %s
; RUN: llvm-lto -debug-pass=Arguments -exported-symbol=_f -o /dev/null %t.bc 2>&1 | FileCheck %s -check-prefix=VERIFY ; RUN: llvm-lto -debug-pass=Arguments -exported-symbol=_f -o /dev/null %t.bc 2>&1 | FileCheck %s -check-prefix=VERIFY
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.10.0" target triple = "x86_64-apple-macosx10.10.0"
; -disable-verify should disable verification from the optimization pipeline. ; -disable-verify should disable verification from the optimization pipeline.
; CHECK: Pass Arguments: ; CHECK: Pass Arguments:
; CHECK-NOT: -verify ; CHECK-NOT: -verify
; VERIFY: Pass Arguments: {{.*}} -verify {{.*}} -verify ; VERIFY: Pass Arguments: {{.*}} -verify {{.*}} -verify
define void @f() { define void @f() {
entry: entry:
ret void ret void
} }

llvm/test/LTO/X86/dllimport.ll

; Test requiring LTO to remove the __imp_ prefix for locally imported COFF ; Test requiring LTO to remove the __imp_ prefix for locally imported COFF
; symbols (mirroring how lld handles these symbols). ; symbols (mirroring how lld handles these symbols).
; RUN: llvm-as %s -o %t.obj ; RUN: llvm-as %s -o %t.obj
; RUN: llvm-as %S/Inputs/dllimport.ll -o %t2.obj ; RUN: llvm-as %S/Inputs/dllimport.ll -o %t2.obj
; RUN: llvm-lto2 run -r=%t.obj,main,px -r %t.obj,__imp_?foo@@YAHXZ -r %t2.obj,?foo@@YAHXZ,p -o %t3 %t.obj %t2.obj -save-temps ; RUN: llvm-lto2 run -r=%t.obj,main,px -r %t.obj,__imp_?foo@@YAHXZ -r %t2.obj,?foo@@YAHXZ,p -o %t3 %t.obj %t2.obj -save-temps
; RUN: llvm-dis %t3.0.0.preopt.bc -o - | FileCheck %s ; RUN: llvm-dis %t3.0.0.preopt.bc -o - | FileCheck %s
; CHECK: define dso_local i32 @"?foo@@YAHXZ"() ; CHECK: define dso_local i32 @"?foo@@YAHXZ"()
; ModuleID = 'a.obj' ; ModuleID = 'a.obj'
source_filename = "a.cpp" source_filename = "a.cpp"
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.11.0" target triple = "x86_64-pc-windows-msvc19.11.0"
; Function Attrs: norecurse nounwind sspstrong uwtable ; Function Attrs: norecurse nounwind sspstrong uwtable
define dso_local i32 @main() local_unnamed_addr { define dso_local i32 @main() local_unnamed_addr {
entry: entry:
%call = tail call i32 @"?foo@@YAHXZ"() %call = tail call i32 @"?foo@@YAHXZ"()
ret i32 %call ret i32 %call
} }
Show All 10 Lines

llvm/test/LTO/X86/internalize.ll

Show All 24 Lines
; INTERNALIZE: define internal void @bar ; INTERNALIZE: define internal void @bar
; INTERNALIZE-OPTION-DISABLE: define void @foo ; INTERNALIZE-OPTION-DISABLE: define void @foo
; INTERNALIZE-OPTION-DISABLE: define void @bar ; INTERNALIZE-OPTION-DISABLE: define void @bar
; INTERNALIZE2: define dso_local void @foo ; INTERNALIZE2: define dso_local void @foo
; INTERNALIZE2: define internal void @bar ; INTERNALIZE2: define internal void @bar
; INTERNALIZE2-OPTION-DISABLE: define dso_local void @foo ; INTERNALIZE2-OPTION-DISABLE: define dso_local void @foo
; INTERNALIZE2-OPTION-DISABLE: define dso_local void @bar ; INTERNALIZE2-OPTION-DISABLE: define dso_local void @bar
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define void @foo() { define void @foo() {
call void @bar() call void @bar()
ret void ret void
} }
define void @bar() { define void @bar() {
ret void ret void
} }

llvm/test/LTO/X86/no-undefined-puts-when-implemented.ll

; RUN: llvm-as <%s >%t1 ; RUN: llvm-as <%s >%t1
; RUN: llvm-lto -exported-symbol=_uses_puts -exported-symbol=_uses_printf -o - %t1 | \ ; RUN: llvm-lto -exported-symbol=_uses_puts -exported-symbol=_uses_printf -o - %t1 | \
; RUN: llvm-nm - | \ ; RUN: llvm-nm - | \
; RUN: FileCheck %s ; RUN: FileCheck %s
; rdar://problem/16165191 ; rdar://problem/16165191
; runtime library implementations should not be renamed ; runtime library implementations should not be renamed
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-darwin11" target triple = "x86_64-apple-darwin11"
@str = private unnamed_addr constant [13 x i8] c"hello world\0A\00" @str = private unnamed_addr constant [13 x i8] c"hello world\0A\00"
; CHECK-NOT: U _puts ; CHECK-NOT: U _puts
; CHECK: T _uses_printf ; CHECK: T _uses_printf
; CHECK: T _uses_puts ; CHECK: T _uses_puts
define i32 @uses_puts(i32 %i) { define i32 @uses_puts(i32 %i) {
Show All 25 Lines

llvm/test/LTO/X86/objc-detection.ll

; RUN: llvm-as < %s -o %t ; RUN: llvm-as < %s -o %t
; RUN: llvm-lto -check-for-objc %t | FileCheck %s ; RUN: llvm-lto -check-for-objc %t | FileCheck %s
; CHECK: contains ObjC ; CHECK: contains ObjC
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.12.0" target triple = "x86_64-apple-macosx10.12.0"
%0 = type opaque %0 = type opaque
%struct._class_t = type { %struct._class_t*, %struct._class_t*, %struct._objc_cache*, i8* (i8*, i8*)**, %struct._class_ro_t* } %struct._class_t = type { %struct._class_t*, %struct._class_t*, %struct._objc_cache*, i8* (i8*, i8*)**, %struct._class_ro_t* }
%struct._objc_cache = type opaque %struct._objc_cache = type opaque
%struct._class_ro_t = type { i32, i32, i32, i8*, i8*, %struct.__method_list_t*, %struct._objc_protocol_list*, %struct._ivar_list_t*, i8*, %struct._prop_list_t* } %struct._class_ro_t = type { i32, i32, i32, i8*, i8*, %struct.__method_list_t*, %struct._objc_protocol_list*, %struct._ivar_list_t*, i8*, %struct._prop_list_t* }
%struct.__method_list_t = type { i32, i32, [0 x %struct._objc_method] } %struct.__method_list_t = type { i32, i32, [0 x %struct._objc_method] }
%struct._objc_method = type { i8*, i8*, i8* } %struct._objc_method = type { i8*, i8*, i8* }
Show All 38 Lines

llvm/test/LTO/X86/pr38046.ll

; RUN: opt -module-summary -o %t.o %s ; RUN: opt -module-summary -o %t.o %s
; RUN: llvm-lto2 run -save-temps -o %t.lto.o %t.o \ ; RUN: llvm-lto2 run -save-temps -o %t.lto.o %t.o \
; RUN: -r=%t.o,foo,plx \ ; RUN: -r=%t.o,foo,plx \
; RUN: -r=%t.o,get,pl ; RUN: -r=%t.o,get,pl
; RUN: llvm-dis %t.lto.o.0.2.internalize.bc >/dev/null 2>%t.dis.stderr || true ; RUN: llvm-dis %t.lto.o.0.2.internalize.bc >/dev/null 2>%t.dis.stderr || true
; RUN: FileCheck -allow-empty %s < %t.dis.stderr ; RUN: FileCheck -allow-empty %s < %t.dis.stderr
; CHECK-NOT: Global is external, but doesn't have external or weak linkage ; CHECK-NOT: Global is external, but doesn't have external or weak linkage
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i32 @foo() { define i32 @foo() {
call void @llvm.dbg.value(metadata i32 ()* @get, metadata !7, metadata !DIExpression()), !dbg !DILocation(scope: !6) call void @llvm.dbg.value(metadata i32 ()* @get, metadata !7, metadata !DIExpression()), !dbg !DILocation(scope: !6)
ret i32 0 ret i32 0
} }
define i32 @get() { define i32 @get() {
Show All 16 Lines

llvm/test/LTO/X86/private-symbol.ll

; RUN: llvm-as < %s >%t1 ; RUN: llvm-as < %s >%t1
; RUN: llvm-lto -o %t2 %t1 ; RUN: llvm-lto -o %t2 %t1
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@.str = private unnamed_addr constant [7 x i8] c"hello\0A\00", align 1 @.str = private unnamed_addr constant [7 x i8] c"hello\0A\00", align 1

llvm/test/LTO/X86/remangle_intrinsics_tbaa.ll

; RUN: llvm-as %s -o %t1.bc ; RUN: llvm-as %s -o %t1.bc
; RUN: llvm-as %p/Inputs/remangle_intrinsics_tbaa.ll -o %t2.bc ; RUN: llvm-as %p/Inputs/remangle_intrinsics_tbaa.ll -o %t2.bc
; RUN: llvm-link -disable-lazy-loading %t2.bc %t1.bc -S | FileCheck %s ; RUN: llvm-link -disable-lazy-loading %t2.bc %t1.bc -S | FileCheck %s
; Verify that we correctly rename the intrinsic and don't crash ; Verify that we correctly rename the intrinsic and don't crash
; CHECK: @llvm.masked.store.v4p0s_some_named_struct.0s.p0v4p0s_some_named_struct.0s ; CHECK: @llvm.masked.store.v4p0s_some_named_struct.0s.p0v4p0s_some_named_struct.0s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
%some_named_struct = type { i8 } %some_named_struct = type { i8 }
define void @foo(%some_named_struct*) { define void @foo(%some_named_struct*) {
call void @llvm.masked.store.v4p0some_named_struct.p0v4p0some_named_struct(<4 x %some_named_struct*> undef, <4 x %some_named_struct*>* undef, i32 8, <4 x i1> undef), !tbaa !5 call void @llvm.masked.store.v4p0some_named_struct.p0v4p0some_named_struct(<4 x %some_named_struct*> undef, <4 x %some_named_struct*>* undef, i32 8, <4 x i1> undef), !tbaa !5
ret void ret void
} }
declare void @llvm.masked.store.v4p0some_named_struct.p0v4p0some_named_struct(<4 x %some_named_struct*>, <4 x %some_named_struct*>*, i32, <4 x i1>) #1 declare void @llvm.masked.store.v4p0some_named_struct.p0v4p0some_named_struct(<4 x %some_named_struct*>, <4 x %some_named_struct*>*, i32, <4 x i1>) #1
!5 = !{!6, !6, i64 0} !5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0} !6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0} !7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"} !8 = !{!"Simple C/C++ TBAA"}

llvm/test/LTO/X86/set-merged.ll

; RUN: llvm-as < %s >%t1 ; RUN: llvm-as < %s >%t1
; RUN: llvm-lto -exported-symbol=_main -set-merged-module -o %t2 %t1 ; RUN: llvm-lto -exported-symbol=_main -set-merged-module -o %t2 %t1
; RUN: llvm-objdump --print-imm-hex=false -d %t2 | FileCheck %s ; RUN: llvm-objdump --print-imm-hex=false -d %t2 | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.10.0" target triple = "x86_64-apple-macosx10.10.0"
; CHECK: _main ; CHECK: _main
; CHECK: movl $132 ; CHECK: movl $132
define i32 @_Z3fooi(i32 %a) { define i32 @_Z3fooi(i32 %a) {
entry: entry:
%a.addr = alloca i32, align 4 %a.addr = alloca i32, align 4
store i32 %a, i32* %a.addr, align 4 store i32 %a, i32* %a.addr, align 4
Show All 23 Lines

llvm/test/LTO/X86/strip-debug-info-no-call-loc.ll

; RUN: llvm-as %s -disable-verify -o %t.bc ; RUN: llvm-as %s -disable-verify -o %t.bc
; RUN: llvm-lto -exported-symbol f -exported-symbol _f \ ; RUN: llvm-lto -exported-symbol f -exported-symbol _f \
; RUN: -o %t.o %t.bc 2>&1 | \ ; RUN: -o %t.o %t.bc 2>&1 | \
; RUN: FileCheck %s -allow-empty -check-prefix=CHECK-WARN ; RUN: FileCheck %s -allow-empty -check-prefix=CHECK-WARN
; RUN: llvm-nm %t.o | FileCheck %s ; RUN: llvm-nm %t.o | FileCheck %s
; Check that missing debug locations on inlinable calls are a ; Check that missing debug locations on inlinable calls are a
; recoverable error. ; recoverable error.
; CHECK-WARN: warning{{.*}} ignoring invalid debug info ; CHECK-WARN: warning{{.*}} ignoring invalid debug info
; CHECK: {{f$}} ; CHECK: {{f$}}
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx" target triple = "x86_64-apple-macosx"
define void @h() #0 !dbg !7 { define void @h() #0 !dbg !7 {
entry: entry:
call void (...) @i(), !dbg !9 call void (...) @i(), !dbg !9
ret void, !dbg !10 ret void, !dbg !10
} }
Show All 35 Lines

llvm/test/LTO/X86/strip-debug-info.ll

Show All 23 Lines
; RUN: -exported-symbol foo -exported-symbol _foo \ ; RUN: -exported-symbol foo -exported-symbol _foo \
; RUN: %t-stripped.bc -disable-verify 2>&1 | \ ; RUN: %t-stripped.bc -disable-verify 2>&1 | \
; RUN: FileCheck %s -allow-empty -check-prefix=CHECK-WARN ; RUN: FileCheck %s -allow-empty -check-prefix=CHECK-WARN
; CHECK-ERR: Broken module found, compilation aborted ; CHECK-ERR: Broken module found, compilation aborted
; CHECK-WARN: warning{{.*}} ignoring invalid debug info ; CHECK-WARN: warning{{.*}} ignoring invalid debug info
; CHECK-WARN-NOT: Broken module found ; CHECK-WARN-NOT: Broken module found
; CHECK: foo ; CHECK: foo
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.12" target triple = "x86_64-apple-macosx10.12"
declare void @bar() declare void @bar()
define void @foo() { define void @foo() {
call void @bar() call void @bar()
ret void ret void
} }
!llvm.module.flags = !{!0} !llvm.module.flags = !{!0}
!llvm.dbg.cu = !{!1} !llvm.dbg.cu = !{!1}
!0 = !{i32 2, !"Debug Info Version", i32 3} !0 = !{i32 2, !"Debug Info Version", i32 3}
!1 = !DIFile(filename: "broken", directory: "") !1 = !DIFile(filename: "broken", directory: "")

llvm/test/LTO/X86/symver-asm.ll

; RUN: llvm-as < %s >%t1 ; RUN: llvm-as < %s >%t1
; RUN: llvm-lto -exported-symbol=io_cancel_0_4 -exported-symbol=io_cancel_weak_0_4 -exported-symbol=foo -o %t2 %t1 ; RUN: llvm-lto -exported-symbol=io_cancel_0_4 -exported-symbol=io_cancel_weak_0_4 -exported-symbol=foo -o %t2 %t1
; RUN: llvm-nm %t2 | FileCheck %s ; RUN: llvm-nm %t2 | FileCheck %s
; RUN: llvm-lto2 run -r %t1,io_cancel_0_4,plx -r %t1,io_cancel_0_4,lx -r %t1,io_cancel_local_0_4,plx -r %t1,io_cancel_weak_0_4,plx -r %t1,io_cancel_weak_0_4,lx -r %t1,io_cancel@@LIBAIO_0.4,plx -r %t1,io_cancel_weak@@LIBAIO_0.4,plx -r %t1,io_cancel_weak@@LIBAIO_0.4.1,plx -r %t1,foo,plx -r %t1,foo,lx -r %t1,foo@@VER1,plx -o %t3 %t1 -save-temps ; RUN: llvm-lto2 run -r %t1,io_cancel_0_4,plx -r %t1,io_cancel_0_4,lx -r %t1,io_cancel_local_0_4,plx -r %t1,io_cancel_weak_0_4,plx -r %t1,io_cancel_weak_0_4,lx -r %t1,io_cancel@@LIBAIO_0.4,plx -r %t1,io_cancel_weak@@LIBAIO_0.4,plx -r %t1,io_cancel_weak@@LIBAIO_0.4.1,plx -r %t1,foo,plx -r %t1,foo,lx -r %t1,foo@@VER1,plx -o %t3 %t1 -save-temps
; RUN: llvm-nm %t3.0 | FileCheck %s ; RUN: llvm-nm %t3.0 | FileCheck %s
; RUN: llvm-dis %t3.0.2.internalize.bc -o - | FileCheck %s --check-prefix=INTERN ; RUN: llvm-dis %t3.0.2.internalize.bc -o - | FileCheck %s --check-prefix=INTERN
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
module asm ".symver io_cancel_0_4,io_cancel@@LIBAIO_0.4" module asm ".symver io_cancel_0_4,io_cancel@@LIBAIO_0.4"
module asm ".symver io_cancel_local_0_4,io_cancel_local@@LIBAIO_0.4" module asm ".symver io_cancel_local_0_4,io_cancel_local@@LIBAIO_0.4"
module asm ".symver io_cancel_weak_0_4,io_cancel_weak@@LIBAIO_0.4" module asm ".symver io_cancel_weak_0_4,io_cancel_weak@@LIBAIO_0.4"
; Ensure we handle case of same aliasee with two version aliases. ; Ensure we handle case of same aliasee with two version aliases.
module asm ".symver io_cancel_weak_0_4,io_cancel_weak@@LIBAIO_0.4.1" module asm ".symver io_cancel_weak_0_4,io_cancel_weak@@LIBAIO_0.4.1"
module asm ".symver foo,foo@@VER1" module asm ".symver foo,foo@@VER1"
Show All 31 Lines

llvm/test/LTO/X86/symver-asm2.ll

; Test to ensure symbol binding works correctly for symver directives, ; Test to ensure symbol binding works correctly for symver directives,
; when the aliased symbols are defined in inline assembly, including ; when the aliased symbols are defined in inline assembly, including
; cases when the symbol attributes are provided after the .symver ; cases when the symbol attributes are provided after the .symver
; directive. ; directive.
; RUN: llvm-as < %s >%t1 ; RUN: llvm-as < %s >%t1
; RUN: llvm-lto -o %t2 %t1 ; RUN: llvm-lto -o %t2 %t1
; RUN: llvm-nm %t2 | FileCheck %s ; RUN: llvm-nm %t2 | FileCheck %s
; RUN: llvm-lto2 run -r %t1,_start,plx -r %t1,_start3,plx -r %t1,foo@@SOME_VERSION -r %t1,foo@SOME_VERSION3 -o %t3 %t1 -save-temps ; RUN: llvm-lto2 run -r %t1,_start,plx -r %t1,_start3,plx -r %t1,foo@@SOME_VERSION -r %t1,foo@SOME_VERSION3 -o %t3 %t1 -save-temps
; RUN: llvm-nm %t3.0 | FileCheck %s ; RUN: llvm-nm %t3.0 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
module asm ".global _start" module asm ".global _start"
module asm "_start:" module asm "_start:"
module asm "_start2:" module asm "_start2:"
module asm "_start3:" module asm "_start3:"
module asm ".symver _start, foo@@SOME_VERSION" module asm ".symver _start, foo@@SOME_VERSION"
module asm ".symver _start2, foo@SOME_VERSION2" module asm ".symver _start2, foo@SOME_VERSION2"
Show All 10 Lines

llvm/test/LTO/X86/symver-asm3.ll

; Test special handling of @@@. ; Test special handling of @@@.
; RUN: llvm-as < %s >%t1 ; RUN: llvm-as < %s >%t1
; RUN: llvm-nm %t1 | FileCheck %s ; RUN: llvm-nm %t1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
module asm "foo1:" module asm "foo1:"
; CHECK-DAG: t foo1 ; CHECK-DAG: t foo1
module asm ".symver foo1, foo@@@VER1" module asm ".symver foo1, foo@@@VER1"
; CHECK-DAG: t foo@@VER1 ; CHECK-DAG: t foo@@VER1
Show All 28 Lines

llvm/test/LTO/X86/tailcallelim.ll

; Check that the LTO pipelines add the Tail Call Elimination pass. ; Check that the LTO pipelines add the Tail Call Elimination pass.
; RUN: llvm-as < %s > %t1 ; RUN: llvm-as < %s > %t1
; RUN: llvm-lto -o %t2 %t1 --exported-symbol=foo -save-merged-module ; RUN: llvm-lto -o %t2 %t1 --exported-symbol=foo -save-merged-module
; RUN: llvm-dis < %t2.merged.bc | FileCheck %s ; RUN: llvm-dis < %t2.merged.bc | FileCheck %s
; RUN: llvm-lto2 run -r %t1,foo,plx -r %t1,bar,plx -o %t3 %t1 -save-temps ; RUN: llvm-lto2 run -r %t1,foo,plx -r %t1,bar,plx -o %t3 %t1 -save-temps
; RUN: llvm-dis < %t3.0.4.opt.bc | FileCheck %s ; RUN: llvm-dis < %t3.0.4.opt.bc | FileCheck %s
; RUN: llvm-lto2 run -r %t1,foo,plx -r %t1,bar,plx -o %t4 %t1 -save-temps -use-new-pm ; RUN: llvm-lto2 run -r %t1,foo,plx -r %t1,bar,plx -o %t4 %t1 -save-temps -use-new-pm
; RUN: llvm-dis < %t4.0.4.opt.bc | FileCheck %s ; RUN: llvm-dis < %t4.0.4.opt.bc | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @foo() { define void @foo() {
; CHECK: tail call void @bar() ; CHECK: tail call void @bar()
call void @bar() call void @bar()
ret void ret void
} }
declare void @bar() declare void @bar()

llvm/test/LTO/X86/triple-init.ll

; Test to ensure that the LTO pipelines add pass to build the TargetLibraryInfo ; Test to ensure that the LTO pipelines add pass to build the TargetLibraryInfo
; using the specified target triple. ; using the specified target triple.
; Check with regular LTO ; Check with regular LTO
; RUN: llvm-as < %s >%t1 ; RUN: llvm-as < %s >%t1
; RUN: llvm-lto -exported-symbol=_main -o %t2 %t1 ; RUN: llvm-lto -exported-symbol=_main -o %t2 %t1
; RUN: llvm-nm %t2 | FileCheck %s ; RUN: llvm-nm %t2 | FileCheck %s
; Check with ThinLTO. Use llvm-lto2 since this adds earlier passes requiring ; Check with ThinLTO. Use llvm-lto2 since this adds earlier passes requiring
; the TargetLibraryInfo with ThinLTO (WholeProgramDevirt). ; the TargetLibraryInfo with ThinLTO (WholeProgramDevirt).
; RUN: opt -module-summary -o %t1 %s ; RUN: opt -module-summary -o %t1 %s
; RUN: llvm-lto2 run -r %t1,_pow, -r %t1,_main,plx -o %t2 %t1 ; RUN: llvm-lto2 run -r %t1,_pow, -r %t1,_main,plx -o %t2 %t1
; RUN: llvm-nm %t2.1 | FileCheck %s ; RUN: llvm-nm %t2.1 | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.9" target triple = "x86_64-apple-macosx10.9"
declare double @pow(double, double) declare double @pow(double, double)
define double @main(double %x) { define double @main(double %x) {
; We check that LTO will be aware of target triple and apply pow to __exp10 transformation. ; We check that LTO will be aware of target triple and apply pow to __exp10 transformation.
; CHECK: U ___exp10 ; CHECK: U ___exp10
%retval = call double @pow(double 10.0, double %x) %retval = call double @pow(double 10.0, double %x)
ret double %retval ret double %retval
} }

llvm/test/LTO/X86/triple-init2.ll

Show All 9 Lines
; RUN: opt -module-summary -o %t1 %s ; RUN: opt -module-summary -o %t1 %s
; RUN: llvm-lto2 run -r %t1,main,plx -o %t2 %t1 ; RUN: llvm-lto2 run -r %t1,main,plx -o %t2 %t1
; RUN: llvm-nm %t2.1 | FileCheck %s ; RUN: llvm-nm %t2.1 | FileCheck %s
; We check that LTO will be aware of target triple and prevent exp2 to ldexpf ; We check that LTO will be aware of target triple and prevent exp2 to ldexpf
; transformation on Windows. ; transformation on Windows.
; CHECK: U exp2f ; CHECK: U exp2f
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.11.0" target triple = "x86_64-pc-windows-msvc19.11.0"
define dso_local i32 @main(i32 %argc, i8** nocapture readnone %argv) local_unnamed_addr { define dso_local i32 @main(i32 %argc, i8** nocapture readnone %argv) local_unnamed_addr {
entry: entry:
%conv = sitofp i32 %argc to float %conv = sitofp i32 %argc to float
%exp2 = tail call float @llvm.exp2.f32(float %conv) %exp2 = tail call float @llvm.exp2.f32(float %conv)
%conv1 = fptosi float %exp2 to i32 %conv1 = fptosi float %exp2 to i32
ret i32 %conv1 ret i32 %conv1
} }
; Function Attrs: nounwind readnone speculatable ; Function Attrs: nounwind readnone speculatable
declare float @llvm.exp2.f32(float) declare float @llvm.exp2.f32(float)

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

; RUN: opt -module-summary -o %t0.o %S/Inputs/type-mapping-bug2.ll ; RUN: opt -module-summary -o %t0.o %S/Inputs/type-mapping-bug2.ll
; RUN: opt -module-summary -o %t1.o %s ; RUN: opt -module-summary -o %t1.o %s
; RUN: llvm-lto2 run -o %t2 %t0.o %t1.o -r %t0.o,c,px -r %t1.o,a,px -r %t1.o,b,px ; RUN: llvm-lto2 run -o %t2 %t0.o %t1.o -r %t0.o,c,px -r %t1.o,a,px -r %t1.o,b,px
; ;
; Test for the issue described in https://bugs.llvm.org/show_bug.cgi?id=37684 ; Test for the issue described in https://bugs.llvm.org/show_bug.cgi?id=37684
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; T1 will be linked against T2 because T2 was already loaded in %t0.o due to ; T1 will be linked against T2 because T2 was already loaded in %t0.o due to
; the declaration for @b being imported due to !13 ; the declaration for @b being imported due to !13
%"T1" = type {} %"T1" = type {}
%"T2" = type {} %"T2" = type {}
define %"T1" @a() { define %"T1" @a() {
Show All 27 Lines

llvm/test/ThinLTO/X86/Inputs/alias_internal.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define internal i32 @f(i8*) unnamed_addr { define internal i32 @f(i8*) unnamed_addr {
ret i32 42 ret i32 42
} }
@a2 = weak alias i32 (i8*), i32 (i8*)* @f @a2 = weak alias i32 (i8*), i32 (i8*)* @f

llvm/test/ThinLTO/X86/Inputs/cache-icall.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @f() !type !0 { define void @f() !type !0 {
entry: entry:
ret void ret void
} }
!0 = !{i64 0, !"_ZTSFvvE"} !0 = !{i64 0, !"_ZTSFvvE"}

llvm/test/ThinLTO/X86/Inputs/cache-import-lists1.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @f1() { define void @f1() {
call void @linkonce_odr() call void @linkonce_odr()
ret void ret void
} }
define linkonce_odr void @linkonce_odr() { define linkonce_odr void @linkonce_odr() {
ret void ret void
} }

llvm/test/ThinLTO/X86/Inputs/cache-import-lists2.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @f2() { define void @f2() {
call void @linkonce_odr() call void @linkonce_odr()
ret void ret void
} }
define linkonce_odr void @linkonce_odr() { define linkonce_odr void @linkonce_odr() {
ret void ret void
} }

llvm/test/ThinLTO/X86/Inputs/cache-typeid-resolutions-import.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i1 @importf1(i8* %p) { define i1 @importf1(i8* %p) {
%x = call i1 @f1(i8* %p) %x = call i1 @f1(i8* %p)
ret i1 %x ret i1 %x
} }
define i1 @importf2(i8* %p) { define i1 @importf2(i8* %p) {
%x = call i1 @f2(i8* %p) %x = call i1 @f2(i8* %p)
ret i1 %x ret i1 %x
} }
declare i1 @f1(i8* %p) declare i1 @f1(i8* %p)
declare i1 @f2(i8* %p) declare i1 @f2(i8* %p)

llvm/test/ThinLTO/X86/Inputs/cache-typeid-resolutions1.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@vt1 = constant i32 0, !type !0 @vt1 = constant i32 0, !type !0
!0 = !{i32 0, !"typeid1"} !0 = !{i32 0, !"typeid1"}

llvm/test/ThinLTO/X86/Inputs/cache-typeid-resolutions2.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@vt2 = constant i1 (i8*)* @vf2, !type !0 @vt2 = constant i1 (i8*)* @vf2, !type !0
define internal i1 @vf2(i8* %this) { define internal i1 @vf2(i8* %this) {
ret i1 0 ret i1 0
} }
!0 = !{i32 0, !"typeid2"} !0 = !{i32 0, !"typeid2"}

llvm/test/ThinLTO/X86/Inputs/cache-typeid-resolutions3.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@vt2a = constant i1 (i8*)* @vf2a, !type !0 @vt2a = constant i1 (i8*)* @vf2a, !type !0
@vt2b = constant i1 (i8*)* @vf2b, !type !0 @vt2b = constant i1 (i8*)* @vf2b, !type !0
define internal i1 @vf2a(i8* %this) { define internal i1 @vf2a(i8* %this) {
ret i1 0 ret i1 0
} }
define internal i1 @vf2b(i8* %this) { define internal i1 @vf2b(i8* %this) {
ret i1 1 ret i1 1
} }
!0 = !{i32 0, !"typeid2"} !0 = !{i32 0, !"typeid2"}

llvm/test/ThinLTO/X86/Inputs/cache.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define i32 @main() { define i32 @main() {
entry: entry:
call void (...) @globalfunc() call void (...) @globalfunc()
ret i32 0 ret i32 0
} }
declare void @globalfunc(...) declare void @globalfunc(...)

llvm/test/ThinLTO/X86/Inputs/callees-metadata.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@fptr = internal unnamed_addr global i32 (i32)* @f2, align 8 @fptr = internal unnamed_addr global i32 (i32)* @f2, align 8
define dso_local i32 @foo(i32 %x) local_unnamed_addr { define dso_local i32 @foo(i32 %x) local_unnamed_addr {
entry: entry:
%0 = load i32 (i32)*, i32 (i32)** @fptr, align 8 %0 = load i32 (i32)*, i32 (i32)** @fptr, align 8
%call = tail call i32 %0(i32 %x), !callees !0 %call = tail call i32 %0(i32 %x), !callees !0
Show All 25 Lines

llvm/test/ThinLTO/X86/Inputs/cfi-distributed.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
%struct.B2 = type { %struct.A2 } %struct.B2 = type { %struct.A2 }
%struct.A2 = type { i32 (...)** } %struct.A2 = type { i32 (...)** }
%struct.B3 = type { %struct.A3 } %struct.B3 = type { %struct.A3 }
%struct.A3 = type { i32 (...)** } %struct.A3 = type { i32 (...)** }
@_ZTV1B2 = constant { [3 x i8*] } { [3 x i8*] [i8* undef, i8* undef, i8* undef] }, !type !0 @_ZTV1B2 = constant { [3 x i8*] } { [3 x i8*] [i8* undef, i8* undef, i8* undef] }, !type !0
Show All 40 Lines

llvm/test/ThinLTO/X86/Inputs/cfi-icall-only-bazqux.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare !type !0 i8 @bar(i8*) declare !type !0 i8 @bar(i8*)
declare i1 @llvm.type.test(i8* %ptr, metadata %type) nounwind readnone declare i1 @llvm.type.test(i8* %ptr, metadata %type) nounwind readnone
define i8 @baz(i8* %p) !type !0 { define i8 @baz(i8* %p) !type !0 {
%x = call i1 @llvm.type.test(i8* %p, metadata !"t1") %x = call i1 @llvm.type.test(i8* %p, metadata !"t1")
%1 = select i1 %x, i8 0, i8 3 %1 = select i1 %x, i8 0, i8 3
Show All 15 Lines

llvm/test/ThinLTO/X86/Inputs/crash_debuginfo.ll

; ModuleID = 'test/ThinLTO/X86/Inputs/crash_debuginfo.ll' ; ModuleID = 'test/ThinLTO/X86/Inputs/crash_debuginfo.ll'
source_filename = "src.bc" source_filename = "src.bc"
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
define void @bar(i32 %arg) { define void @bar(i32 %arg) {
%tmp = add i32 %arg, 0, !dbg !8 %tmp = add i32 %arg, 0, !dbg !8
unreachable unreachable
} }
!llvm.dbg.cu = !{!0} !llvm.dbg.cu = !{!0}
Show All 22 Lines

llvm/test/ThinLTO/X86/Inputs/deadstrip.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
declare void @dead_func() declare void @dead_func()
; Called from a @dead_func() in the other file, should not be imported there ; Called from a @dead_func() in the other file, should not be imported there
; Ensure the cycle formed by calling @dead_func doesn't prevent stripping. ; Ensure the cycle formed by calling @dead_func doesn't prevent stripping.
define void @baz() { define void @baz() {
call void @dead_func() call void @dead_func()
Show All 18 Lines

llvm/test/ThinLTO/X86/Inputs/debuginfo-compositetype-import.ll

; ModuleID = 'debuginfo-compositetype-import2.c' ; ModuleID = 'debuginfo-compositetype-import2.c'
source_filename = "debuginfo-compositetype-import2.c" source_filename = "debuginfo-compositetype-import2.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define i32 @main() { define i32 @main() {
entry: entry:
call void (...) @foo() call void (...) @foo()
ret i32 0 ret i32 0
} }
declare void @foo(...) #1 declare void @foo(...) #1

llvm/test/ThinLTO/X86/Inputs/debuginfo-cu-import.ll

; ModuleID = 'debuginfo-cu-import2.c' ; ModuleID = 'debuginfo-cu-import2.c'
source_filename = "debuginfo-cu-import2.c" source_filename = "debuginfo-cu-import2.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define i32 @main() { define i32 @main() {
entry: entry:
call void (...) @foo() call void (...) @foo()
ret i32 0 ret i32 0
} }
declare void @foo(...) #1 declare void @foo(...) #1

llvm/test/ThinLTO/X86/Inputs/devirt2.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
%struct.A = type { i32 (...)** } %struct.A = type { i32 (...)** }
%struct.B = type { %struct.A } %struct.B = type { %struct.A }
%struct.C = type { %struct.A } %struct.C = type { %struct.A }
%struct.D = type { i32 (...)** } %struct.D = type { i32 (...)** }
%struct.E = type { i32 (...)** } %struct.E = type { i32 (...)** }
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/test/ThinLTO/X86/Inputs/diagnostic-handler-remarks.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
declare i32 @bar() declare i32 @bar()
define i32 @foo() { define i32 @foo() {
%a = call i32 @bar() %a = call i32 @bar()
ret i32 %a ret i32 %a
} }

llvm/test/ThinLTO/X86/Inputs/dicompositetype-unique-alias.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-scei-ps4" target triple = "x86_64-scei-ps4"
%struct.CFVS = type { %struct.Vec } %struct.CFVS = type { %struct.Vec }
%struct.Vec = type { i8 } %struct.Vec = type { i8 }
%struct.S = type { i8 } %struct.S = type { i8 }
@_ZN4CFVSD1Ev = alias void (%struct.CFVS*), void (%struct.CFVS*)* @_ZN4CFVSD2Ev @_ZN4CFVSD1Ev = alias void (%struct.CFVS*), void (%struct.CFVS*)* @_ZN4CFVSD2Ev
Show All 30 Lines

llvm/test/ThinLTO/X86/Inputs/dicompositetype-unique.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define void @foo() { define void @foo() {
ret void ret void
} }
!named = !{!0, !1, !2, !3} !named = !{!0, !1, !2, !3}
!0 = !DIFile(filename: "abc", directory: "/path/to") !0 = !DIFile(filename: "abc", directory: "/path/to")
!1 = !DICompositeType(tag: DW_TAG_class_type, name: "T2", identifier: "T", file: !0) !1 = !DICompositeType(tag: DW_TAG_class_type, name: "T2", identifier: "T", file: !0)
!2 = !DICompositeType(tag: DW_TAG_class_type, name: "FwdTDef", identifier: "FwdT", file: !0) !2 = !DICompositeType(tag: DW_TAG_class_type, name: "FwdTDef", identifier: "FwdT", file: !0)
!3 = !DICompositeType(tag: DW_TAG_class_type, flags: DIFlagFwdDecl, name: "BothFwdT2", identifier: "BothFwdT", file: !0) !3 = !DICompositeType(tag: DW_TAG_class_type, flags: DIFlagFwdDecl, name: "BothFwdT2", identifier: "BothFwdT", file: !0)

llvm/test/ThinLTO/X86/Inputs/dicompositetype-unique2.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-scei-ps4" target triple = "x86_64-scei-ps4"
%struct.CFVS = type { %struct.Vec } %struct.CFVS = type { %struct.Vec }
%struct.Vec = type { i8 } %struct.Vec = type { i8 }
%struct.S = type { i8 } %struct.S = type { i8 }
define void @_ZN4CFVSD2Ev(%struct.CFVS* %this) unnamed_addr align 2 !dbg !8 { define void @_ZN4CFVSD2Ev(%struct.CFVS* %this) unnamed_addr align 2 !dbg !8 {
entry: entry:
Show All 37 Lines

llvm/test/ThinLTO/X86/Inputs/dot-dumper.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@A = local_unnamed_addr global i32 10, align 4 @A = local_unnamed_addr global i32 10, align 4
@B = local_unnamed_addr global i32 20, align 4 @B = local_unnamed_addr global i32 20, align 4
; Function Attrs: norecurse nounwind readonly uwtable ; Function Attrs: norecurse nounwind readonly uwtable
define i32 @foo() local_unnamed_addr #0 { define i32 @foo() local_unnamed_addr #0 {
%1 = load i32, i32* @B, align 4 %1 = load i32, i32* @B, align 4
Show All 11 Lines

llvm/test/ThinLTO/X86/Inputs/dot-dumper2.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@A = local_unnamed_addr global i32 10, align 4 @A = local_unnamed_addr global i32 10, align 4

llvm/test/ThinLTO/X86/Inputs/drop-debug-info.ll

; This file is checked-in as a .bc file, because the debug info version is ; This file is checked-in as a .bc file, because the debug info version is
; intentionally out-of-date and llvm-as will drop it before writing the bitcode ; intentionally out-of-date and llvm-as will drop it before writing the bitcode
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
@argc = global i8 0, align 1, !dbg !21 @argc = global i8 0, align 1, !dbg !21
define void @globalfunc() { define void @globalfunc() {
entry: entry:
%0 = load i8, i8* @argc, align 1 %0 = load i8, i8* @argc, align 1
Show All 35 Lines

llvm/test/ThinLTO/X86/Inputs/dsolocal_dllimport.ll

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.11.0" target triple = "x86_64-pc-windows-msvc19.11.0"
define dso_local dllexport i32 @foo() { define dso_local dllexport i32 @foo() {
ret i32 42 ret i32 42
} }

llvm/test/ThinLTO/X86/Inputs/emit_imports.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @g() { define void @g() {
entry: entry:
ret void ret void
} }

llvm/test/ThinLTO/X86/Inputs/emit_imports2.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @h() { define void @h() {
entry: entry:
ret void ret void
} }

llvm/test/ThinLTO/X86/Inputs/empty.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"

llvm/test/ThinLTO/X86/Inputs/empty_module_with_cache.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define i32 @main() { define i32 @main() {
entry: entry:
ret i32 0 ret i32 0
} }

llvm/test/ThinLTO/X86/Inputs/export.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define i32 @main() #0 { define i32 @main() #0 {
entry: entry:
call void @callstaticfunc() call void @callstaticfunc()
ret i32 0 ret i32 0
} }
declare void @callstaticfunc() declare void @callstaticfunc()

llvm/test/ThinLTO/X86/Inputs/funcimport-debug.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define void @foo() #0 { define void @foo() #0 {
entry: entry:
ret void ret void
} }
@baz = constant i32 10, align 4 @baz = constant i32 10, align 4

llvm/test/ThinLTO/X86/Inputs/funcimport-tbaa.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define i32 @main() { define i32 @main() {
entry: entry:
%unused = call float @globalfunc1(i32* null, float*null) %unused = call float @globalfunc1(i32* null, float*null)
ret i32 0 ret i32 0
} }
declare float @globalfunc1(i32*, float*) declare float @globalfunc1(i32*, float*)
No newline at end of file No newline at end of file

llvm/test/ThinLTO/X86/Inputs/funcimport.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define i32 @main() #0 { define i32 @main() #0 {
entry: entry:
call void (...) @weakalias() call void (...) @weakalias()
call void (...) @analias() call void (...) @analias()
%call = call i32 (...) @referencestatics() %call = call i32 (...) @referencestatics()
Show All 23 Lines

llvm/test/ThinLTO/X86/Inputs/funcimport2.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define i32 @main() #0 { define i32 @main() #0 {
entry: entry:
call void (...) @foo() call void (...) @foo()
ret i32 0 ret i32 0
} }
declare void @foo(...) #1 declare void @foo(...) #1

llvm/test/ThinLTO/X86/Inputs/function_entry_count.ll

target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
declare void @h(); declare void @h();
define void @g() { define void @g() {
call void @h(); call void @h();
ret void ret void
} }

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

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@label_addr = internal constant [1 x i8*] [i8* blockaddress(@foo, %lb)], align 8 @label_addr = internal constant [1 x i8*] [i8* blockaddress(@foo, %lb)], align 8
; Function Attrs: noinline norecurse nounwind optnone uwtable ; Function Attrs: noinline norecurse nounwind optnone uwtable
define dso_local [1 x i8*]* @foo() { define dso_local [1 x i8*]* @foo() {
br label %lb br label %lb
lb: lb:
ret [1 x i8*]* @label_addr ret [1 x i8*]* @label_addr
} }

llvm/test/ThinLTO/X86/Inputs/globals-import-cf-baz.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
@baz = local_unnamed_addr constant i32 10, align 4 @baz = local_unnamed_addr constant i32 10, align 4

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

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
@baz = internal constant i32 10, align 4 @baz = internal constant i32 10, align 4
define linkonce_odr i32 @foo() { define linkonce_odr i32 @foo() {
%1 = load i32, i32* @baz, align 4 %1 = load i32, i32* @baz, align 4
ret i32 %1 ret i32 %1
} }

llvm/test/ThinLTO/X86/Inputs/import_opaque_type.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
%0 = type { i8 } %0 = type { i8 }
%a = type { %0 * } %a = type { %0 * }
define void @bar(%a *) { define void @bar(%a *) {
ret void ret void
} }
define void @baz() { define void @baz() {
call void @bar(%a *null) call void @bar(%a *null)
ret void ret void
} }

llvm/test/ThinLTO/X86/Inputs/index-const-prop-alias.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@g = global i32 42, align 4 @g = global i32 42, align 4
@g.alias = weak alias i32, i32* @g @g.alias = weak alias i32, i32* @g

llvm/test/ThinLTO/X86/Inputs/index-const-prop-cache-foo.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@gFoo = internal unnamed_addr global i32 1, align 4 @gFoo = internal unnamed_addr global i32 1, align 4
; Function Attrs: norecurse nounwind readonly ssp uwtable ; Function Attrs: norecurse nounwind readonly ssp uwtable
define i32 @foo() local_unnamed_addr { define i32 @foo() local_unnamed_addr {
%1 = load i32, i32* @gFoo, align 4 %1 = load i32, i32* @gFoo, align 4
ret i32 %1 ret i32 %1
Show All 10 Lines

llvm/test/ThinLTO/X86/Inputs/index-const-prop-cache-test1.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define i32 @test() local_unnamed_addr { define i32 @test() local_unnamed_addr {
%1 = tail call i32 (...) @foo() %1 = tail call i32 (...) @foo()
ret i32 %1 ret i32 %1
} }
declare i32 @foo(...) local_unnamed_addr declare i32 @foo(...) local_unnamed_addr

llvm/test/ThinLTO/X86/Inputs/index-const-prop-cache-test2.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define i32 @test() local_unnamed_addr { define i32 @test() local_unnamed_addr {
%1 = tail call i32 (...) @foo() %1 = tail call i32 (...) @foo()
%2 = tail call i32 (...) @bar() %2 = tail call i32 (...) @bar()
%3 = add nsw i32 %2, %1 %3 = add nsw i32 %2, %1
ret i32 %3 ret i32 %3
} }
declare i32 @foo(...) local_unnamed_addr declare i32 @foo(...) local_unnamed_addr
declare i32 @bar(...) local_unnamed_addr declare i32 @bar(...) local_unnamed_addr

llvm/test/ThinLTO/X86/Inputs/index-const-prop-comdat.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
$comdat.any = comdat any $comdat.any = comdat any
@g = global i32 42, comdat($comdat.any) @g = global i32 42, comdat($comdat.any)

llvm/test/ThinLTO/X86/Inputs/index-const-prop-define-g.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@g = global i32 42, align 4 @g = global i32 42, align 4

llvm/test/ThinLTO/X86/Inputs/index-const-prop-full-lto.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@g = external global i32 @g = external global i32
define i32 @foo() { define i32 @foo() {
%v = load i32, i32* @g %v = load i32, i32* @g
ret i32 %v ret i32 %v
} }
!0 = !{i32 1, !"ThinLTO", i32 0} !0 = !{i32 1, !"ThinLTO", i32 0}
!llvm.module.flags = !{ !0 } !llvm.module.flags = !{ !0 }

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

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@b = global i32* @a, align 8 @b = global i32* @a, align 8
@a = global i32 42, align 4 @a = global i32 42, align 4

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

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@g1 = common global i32 0, align 4 @g1 = common global i32 0, align 4
@g2 = global i32 42, align 4 @g2 = global i32 42, align 4
@g3 = available_externally global i32 42, align 4 @g3 = available_externally global i32 42, align 4
define i32 @foo() { define i32 @foo() {
%v1 = load i32, i32* @g1 %v1 = load i32, i32* @g1
%v2 = load i32, i32* @g2 %v2 = load i32, i32* @g2
%v3 = load i32, i32* @g3 %v3 = load i32, i32* @g3
%s1 = add i32 %v1, %v2 %s1 = add i32 %v1, %v2
%s2 = add i32 %s1, %v3 %s2 = add i32 %s1, %v3
ret i32 %s2 ret i32 %s2
} }

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

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
@gBar = local_unnamed_addr global i32 2, align 4, !dbg !0 @gBar = local_unnamed_addr global i32 2, align 4, !dbg !0
@gFoo = internal unnamed_addr global i32 1, align 4, !dbg !6 @gFoo = internal unnamed_addr global i32 1, align 4, !dbg !6
; Function Attrs: norecurse nounwind readonly ; Function Attrs: norecurse nounwind readonly
define i32 @foo() local_unnamed_addr #0 !dbg !14 { define i32 @foo() local_unnamed_addr #0 !dbg !14 {
%1 = load i32, i32* @gFoo, align 4, !dbg !17 %1 = load i32, i32* @gFoo, align 4, !dbg !17
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

llvm/test/ThinLTO/X86/Inputs/lazyload_metadata.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
declare void @globalfunc1() declare void @globalfunc1()
define i32 @main() { define i32 @main() {
call void @globalfunc1() call void @globalfunc1()
ret i32 0 ret i32 0
} }

llvm/test/ThinLTO/X86/Inputs/linkonce_aliasee_ref_import.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
define i32 @main() #0 { define i32 @main() #0 {
entry: entry:
call void @foo() call void @foo()
ret i32 0 ret i32 0
} }
declare void @foo() declare void @foo()

llvm/test/ThinLTO/X86/Inputs/linkonce_odr_unnamed_addr.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
@linkonceodrunnamed = linkonce_odr unnamed_addr constant i32 0 @linkonceodrunnamed = linkonce_odr unnamed_addr constant i32 0
@odrunnamed = weak_odr unnamed_addr constant i32 0 @odrunnamed = weak_odr unnamed_addr constant i32 0

llvm/test/ThinLTO/X86/Inputs/linkonce_resolution_comdat.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
$c2 = comdat any $c2 = comdat any
define linkonce_odr i32 @f(i8*) unnamed_addr comdat($c2) { define linkonce_odr i32 @f(i8*) unnamed_addr comdat($c2) {
ret i32 41 ret i32 41
} }
define i32 @g() { define i32 @g() {
%i = call i32 @f(i8* null) %i = call i32 @f(i8* null)
ret i32 %i ret i32 %i
} }

llvm/test/ThinLTO/X86/Inputs/llvm.used.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define i32 @main() #0 { define i32 @main() #0 {
entry: entry:
call void (...) @globalfunc() call void (...) @globalfunc()
ret i32 0 ret i32 0
} }
declare void @globalfunc(...) declare void @globalfunc(...)
No newline at end of file No newline at end of file

llvm/test/ThinLTO/X86/Inputs/local_name_conflict1.ll

; ModuleID = 'local_name_conflict.o' ; ModuleID = 'local_name_conflict.o'
source_filename = "local_name_conflict.c" source_filename = "local_name_conflict.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@baz = internal constant i32 10, align 4 @baz = internal constant i32 10, align 4
; Function Attrs: noinline nounwind uwtable ; Function Attrs: noinline nounwind uwtable
define i32 @a() { define i32 @a() {
entry: entry:
%call = call i32 @foo() %call = call i32 @foo()
Show All 9 Lines

llvm/test/ThinLTO/X86/Inputs/local_name_conflict2.ll

; ModuleID = 'local_name_conflict.o' ; ModuleID = 'local_name_conflict.o'
source_filename = "local_name_conflict.c" source_filename = "local_name_conflict.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@baz = internal constant i32 10, align 4 @baz = internal constant i32 10, align 4
; Function Attrs: noinline nounwind uwtable ; Function Attrs: noinline nounwind uwtable
define i32 @b() { define i32 @b() {
entry: entry:
%call = call i32 @foo() %call = call i32 @foo()
Show All 9 Lines

llvm/test/ThinLTO/X86/Inputs/local_name_conflict_var1.ll

; ModuleID = 'local_name_conflict_var.o' ; ModuleID = 'local_name_conflict_var.o'
source_filename = "local_name_conflict_var.c" source_filename = "local_name_conflict_var.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@baz = internal global i32 10, align 4 @baz = internal global i32 10, align 4
; Function Attrs: noinline nounwind uwtable ; Function Attrs: noinline nounwind uwtable
define i32 @a() { define i32 @a() {
entry: entry:
%0 = load i32, i32* @baz, align 4 %0 = load i32, i32* @baz, align 4
ret i32 %0 ret i32 %0
} }

llvm/test/ThinLTO/X86/Inputs/local_name_conflict_var2.ll

; ModuleID = 'local_name_conflict_var.o' ; ModuleID = 'local_name_conflict_var.o'
source_filename = "local_name_conflict_var.c" source_filename = "local_name_conflict_var.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@baz = internal global i32 10, align 4 @baz = internal global i32 10, align 4
; Function Attrs: noinline nounwind uwtable ; Function Attrs: noinline nounwind uwtable
define i32 @b() { define i32 @b() {
entry: entry:
%0 = load i32, i32* @baz, align 4 %0 = load i32, i32* @baz, align 4
ret i32 %0 ret i32 %0
} }

llvm/test/ThinLTO/X86/Inputs/merge-triple.ll

target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"

llvm/test/ThinLTO/X86/Inputs/module_asm.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i32 @main({ i64, { i64, i8* }* } %unnamed) #0 { define i32 @main({ i64, { i64, i8* }* } %unnamed) #0 {
%1 = call i32 @_simplefunction() #1 %1 = call i32 @_simplefunction() #1
ret i32 %1 ret i32 %1
} }
declare i32 @_simplefunction() #1 declare i32 @_simplefunction() #1

llvm/test/ThinLTO/X86/Inputs/module_asm2.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i32 @main({ i64, { i64, i8* }* } %unnamed) #0 { define i32 @main({ i64, { i64, i8* }* } %unnamed) #0 {
%1 = call i32 @func1() #1 %1 = call i32 @func1() #1
%2 = call i32 @func2() #1 %2 = call i32 @func2() #1
%3 = call i32 @func3() #1 %3 = call i32 @func3() #1
%4 = call i32 @callglobalfunc() #1 %4 = call i32 @callglobalfunc() #1
%5 = call i32 @callweakfunc() #1 %5 = call i32 @callweakfunc() #1
ret i32 %1 ret i32 %1
} }
declare i32 @func1() #1 declare i32 @func1() #1
declare i32 @func2() #1 declare i32 @func2() #1
declare i32 @func3() #1 declare i32 @func3() #1
declare i32 @callglobalfunc() #1 declare i32 @callglobalfunc() #1
declare i32 @callweakfunc() #1 declare i32 @callweakfunc() #1

llvm/test/ThinLTO/X86/Inputs/noinline.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
define i32 @foo(i32) local_unnamed_addr #0 { define i32 @foo(i32) local_unnamed_addr #0 {
ret i32 10 ret i32 10
} }
attributes #0 = { noinline } attributes #0 = { noinline }

llvm/test/ThinLTO/X86/Inputs/personality-local.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
define void @foo() { define void @foo() {
ret void ret void
} }

llvm/test/ThinLTO/X86/Inputs/personality.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
define void @bar() personality i32 (i32, i32, i64, i8*, i8*)* @personality_routine { define void @bar() personality i32 (i32, i32, i64, i8*, i8*)* @personality_routine {
ret void ret void
} }
define protected i32 @personality_routine(i32, i32, i64, i8*, i8*) { define protected i32 @personality_routine(i32, i32, i64, i8*, i8*) {
ret i32 0 ret i32 0
Show All 9 Lines

llvm/test/ThinLTO/X86/Inputs/pr35472.ll

; ModuleID = 'b.cpp' ; ModuleID = 'b.cpp'
source_filename = "b.cpp" source_filename = "b.cpp"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: noinline optnone uwtable ; Function Attrs: noinline optnone uwtable
define void @_Z5Alphav() { define void @_Z5Alphav() {
entry: entry:
call void @_Z5Bravov() call void @_Z5Bravov()
ret void ret void
} }
declare void @_Z5Bravov() declare void @_Z5Bravov()

llvm/test/ThinLTO/X86/Inputs/reference_non_importable.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
declare i8 **@foo() declare i8 **@foo()
define i32 @main() { define i32 @main() {
call i8 **@foo() call i8 **@foo()
ret i32 0 ret i32 0
} }

llvm/test/ThinLTO/X86/Inputs/referenced_by_constant.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define void @referencedbyglobal() { define void @referencedbyglobal() {
ret void ret void
} }
define internal void @localreferencedbyglobal() { define internal void @localreferencedbyglobal() {
ret void ret void
Show All 12 Lines

llvm/test/ThinLTO/X86/Inputs/strong_non_prevailing.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
$__llvm_profile_filename = comdat any $__llvm_profile_filename = comdat any
@__llvm_profile_filename = constant [19 x i8] c"default_%m.profraw\00", comdat @__llvm_profile_filename = constant [19 x i8] c"default_%m.profraw\00", comdat

llvm/test/ThinLTO/X86/Inputs/thinlto-internalize-used2.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.15.0" target triple = "x86_64-apple-macosx10.15.0"
define i32 @main() { define i32 @main() {
entry: entry:
%call = call i32 @bar() %call = call i32 @bar()
ret i32 0 ret i32 0
} }
declare i32 @bar() declare i32 @bar()

llvm/test/ThinLTO/X86/Inputs/weak_resolution.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
; Alias are not optimized ; Alias are not optimized
@linkonceodralias = linkonce_odr alias void (), void ()* @linkonceodrfuncwithalias @linkonceodralias = linkonce_odr alias void (), void ()* @linkonceodrfuncwithalias
; Alias are not optimized ; Alias are not optimized
@linkoncealias = linkonce alias void (), void ()* @linkoncefuncwithalias @linkoncealias = linkonce alias void (), void ()* @linkoncefuncwithalias
Show All 29 Lines

llvm/test/ThinLTO/X86/alias_internal.ll

; Test to make sure dot dumper can correctly handle aliases to multiple ; Test to make sure dot dumper can correctly handle aliases to multiple
; different internal aliasees with the same name. ; different internal aliasees with the same name.
; RUN: opt -module-summary %s -o %t1.bc ; RUN: opt -module-summary %s -o %t1.bc
; RUN: opt -module-summary %p/Inputs/alias_internal.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/alias_internal.ll -o %t2.bc
; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t.out -save-temps \ ; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t.out -save-temps \
; RUN: -r %t1.bc,a1,plx \ ; RUN: -r %t1.bc,a1,plx \
; RUN: -r %t2.bc,a2,plx ; RUN: -r %t2.bc,a2,plx
; RUN: cat %t.out.index.dot | FileCheck %s ; RUN: cat %t.out.index.dot | FileCheck %s
; CHECK-DAG: M0_12511626713252727690 -> M0_{{.*}} // alias ; CHECK-DAG: M0_12511626713252727690 -> M0_{{.*}} // alias
; CHECK-DAG: M1_8129049334585965161 -> M1_{{.*}} // alias ; CHECK-DAG: M1_8129049334585965161 -> M1_{{.*}} // alias
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define internal i32 @f(i8*) unnamed_addr { define internal i32 @f(i8*) unnamed_addr {
ret i32 42 ret i32 42
} }
@a1 = weak alias i32 (i8*), i32 (i8*)* @f @a1 = weak alias i32 (i8*), i32 (i8*)* @f

llvm/test/ThinLTO/X86/autoupgrade.ll

Show All 13 Lines
; Check that the summary is able to print the names despite the lack of ; Check that the summary is able to print the names despite the lack of
; string table in the legacy bitcode. ; string table in the legacy bitcode.
; RUN: llvm-dis %p/Inputs/autoupgrade.bc -o - \ ; RUN: llvm-dis %p/Inputs/autoupgrade.bc -o - \
; RUN: | FileCheck %s --check-prefix=SUMMARYNAMES ; RUN: | FileCheck %s --check-prefix=SUMMARYNAMES
; SUMMARYNAMES: ^2 = gv: (name: "globalfunc2", ; SUMMARYNAMES: ^2 = gv: (name: "globalfunc2",
; SUMMARYNAMES: ^3 = gv: (name: "globalfunc1" ; SUMMARYNAMES: ^3 = gv: (name: "globalfunc1"
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define i32 @main() #0 { define i32 @main() #0 {
entry: entry:
call void (...) @globalfunc1() call void (...) @globalfunc1()
ret i32 0 ret i32 0
} }
declare void @globalfunc1(...) #1 declare void @globalfunc1(...) #1

llvm/test/ThinLTO/X86/builtin-nostrip.ll

Show All 40 Lines
; CHECK-NM-NOT: bar ; CHECK-NM-NOT: bar
; CHECK-NM-DAG: T __stack_chk_fail ; CHECK-NM-DAG: T __stack_chk_fail
; CHECK-NM-NOT: bar ; CHECK-NM-NOT: bar
; Test case for old lto without thinlto. Hopefully these can be ; Test case for old lto without thinlto. Hopefully these can be
; eliminated once the old lto interface is fixed. ; eliminated once the old lto interface is fixed.
; CHECK-NM2-DAG: t __stack_chk_fail ; CHECK-NM2-DAG: t __stack_chk_fail
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @bar() { define void @bar() {
ret void ret void
} }
define void @__stack_chk_fail() { define void @__stack_chk_fail() {
ret void ret void
} }

llvm/test/ThinLTO/X86/cache-config.ll

Show All 12 Lines
; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -cg-opt-level=0 ; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -cg-opt-level=0
; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -O1 ; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -O1
; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -opt-pipeline=loweratomic ; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -opt-pipeline=loweratomic
; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -aa-pipeline=basic-aa ; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -aa-pipeline=basic-aa
; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -override-triple=x86_64-unknown-linux-gnu ; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -override-triple=x86_64-unknown-linux-gnu
; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -default-triple=x86_64-unknown-linux-gnu ; RUN: llvm-lto2 run -o %t.o %t.bc -cache-dir %t.cache -r=%t.bc,globalfunc,plx -default-triple=x86_64-unknown-linux-gnu
; RUN: ls %t.cache | count 15 ; RUN: ls %t.cache | count 15
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @globalfunc() { define void @globalfunc() {
entry: entry:
ret void ret void
} }

llvm/test/ThinLTO/X86/cache-icall.ll

Show All 23 Lines
; SYMBOLS-NO-DAG: {{FUNC .* f.cfi_jt$}} ; SYMBOLS-NO-DAG: {{FUNC .* f.cfi_jt$}}
; SYMBOLS-NO-DAG: {{NOTYPE .* UND f.cfi_jt$}} ; SYMBOLS-NO-DAG: {{NOTYPE .* UND f.cfi_jt$}}
; SYMBOLS-YES-NOT: f.cfi_jt ; SYMBOLS-YES-NOT: f.cfi_jt
; SYMBOLS-YES-DAG: {{FUNC .* f.cfi$}} ; SYMBOLS-YES-DAG: {{FUNC .* f.cfi$}}
; SYMBOLS-YES-DAG: {{NOTYPE .* UND f.cfi$}} ; SYMBOLS-YES-DAG: {{NOTYPE .* UND f.cfi$}}
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i8* @_start(void ()* %p) !type !0 { define i8* @_start(void ()* %p) !type !0 {
entry: entry:
%0 = bitcast void ()* %p to i8* %0 = bitcast void ()* %p to i8*
%1 = tail call i1 @llvm.type.test(i8* %0, metadata !"_ZTSFvvE") %1 = tail call i1 @llvm.type.test(i8* %0, metadata !"_ZTSFvvE")
br i1 %1, label %cont, label %trap br i1 %1, label %cont, label %trap
Show All 15 Lines

llvm/test/ThinLTO/X86/cache-import-lists.ll

; RUN: opt -module-hash -module-summary %s -o %t.bc ; RUN: opt -module-hash -module-summary %s -o %t.bc
; RUN: opt -module-hash -module-summary %S/Inputs/cache-import-lists1.ll -o %t1.bc ; RUN: opt -module-hash -module-summary %S/Inputs/cache-import-lists1.ll -o %t1.bc
; RUN: opt -module-hash -module-summary %S/Inputs/cache-import-lists2.ll -o %t2.bc ; RUN: opt -module-hash -module-summary %S/Inputs/cache-import-lists2.ll -o %t2.bc
; Tests that the hash for t is sensitive to the set of imported functions ; Tests that the hash for t is sensitive to the set of imported functions
; for each module, which in this case depends on the link order (the function ; for each module, which in this case depends on the link order (the function
; linkonce_odr will be imported from either t1 or t2, whichever comes first). ; linkonce_odr will be imported from either t1 or t2, whichever comes first).
; RUN: rm -rf %t.cache ; RUN: rm -rf %t.cache
; RUN: llvm-lto2 run -cache-dir %t.cache -o %t.o %t.bc %t1.bc %t2.bc -r=%t.bc,main,plx -r=%t.bc,f1,lx -r=%t.bc,f2,lx -r=%t1.bc,f1,plx -r=%t1.bc,linkonce_odr,plx -r=%t2.bc,f2,plx -r=%t2.bc,linkonce_odr,lx ; RUN: llvm-lto2 run -cache-dir %t.cache -o %t.o %t.bc %t1.bc %t2.bc -r=%t.bc,main,plx -r=%t.bc,f1,lx -r=%t.bc,f2,lx -r=%t1.bc,f1,plx -r=%t1.bc,linkonce_odr,plx -r=%t2.bc,f2,plx -r=%t2.bc,linkonce_odr,lx
; RUN: llvm-lto2 run -cache-dir %t.cache -o %t.o %t.bc %t2.bc %t1.bc -r=%t.bc,main,plx -r=%t.bc,f1,lx -r=%t.bc,f2,lx -r=%t2.bc,f2,plx -r=%t2.bc,linkonce_odr,plx -r=%t1.bc,f1,plx -r=%t1.bc,linkonce_odr,lx ; RUN: llvm-lto2 run -cache-dir %t.cache -o %t.o %t.bc %t2.bc %t1.bc -r=%t.bc,main,plx -r=%t.bc,f1,lx -r=%t.bc,f2,lx -r=%t2.bc,f2,plx -r=%t2.bc,linkonce_odr,plx -r=%t1.bc,f1,plx -r=%t1.bc,linkonce_odr,lx
; RUN: ls %t.cache | count 6 ; RUN: ls %t.cache | count 6
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @main() { define void @main() {
call void @f1() call void @f1()
call void @f2() call void @f2()
ret void ret void
} }
declare void @f1() declare void @f1()
declare void @f2() declare void @f2()

llvm/test/ThinLTO/X86/cache-typeid-resolutions.ll

Show All 16 Lines
; where both t and t-import are sensitive to typeid2's resolution ; where both t and t-import are sensitive to typeid2's resolution
; so 6 distinct objects in total. ; so 6 distinct objects in total.
; RUN: rm -rf %t.cache ; RUN: rm -rf %t.cache
; RUN: llvm-lto2 run -o %t.o %t.bc %t-import.bc -cache-dir %t.cache -r=%t.bc,f1,plx -r=%t.bc,f2,plx -r=%t.bc,f1_actual,plx -r=%t-import.bc,importf1,plx -r=%t-import.bc,f1,lx -r=%t-import.bc,importf2,plx -r=%t-import.bc,f2,lx ; RUN: llvm-lto2 run -o %t.o %t.bc %t-import.bc -cache-dir %t.cache -r=%t.bc,f1,plx -r=%t.bc,f2,plx -r=%t.bc,f1_actual,plx -r=%t-import.bc,importf1,plx -r=%t-import.bc,f1,lx -r=%t-import.bc,importf2,plx -r=%t-import.bc,f2,lx
; RUN: llvm-lto2 run -o %t.o %t.bc %t-import.bc %t2.bc -cache-dir %t.cache -r=%t.bc,f1,plx -r=%t.bc,f2,plx -r=%t.bc,f1_actual,plx -r=%t2.bc,vt2,plx -r=%t-import.bc,importf1,plx -r=%t-import.bc,f1,lx -r=%t-import.bc,importf2,plx -r=%t-import.bc,f2,lx ; RUN: llvm-lto2 run -o %t.o %t.bc %t-import.bc %t2.bc -cache-dir %t.cache -r=%t.bc,f1,plx -r=%t.bc,f2,plx -r=%t.bc,f1_actual,plx -r=%t2.bc,vt2,plx -r=%t-import.bc,importf1,plx -r=%t-import.bc,f1,lx -r=%t-import.bc,importf2,plx -r=%t-import.bc,f2,lx
; RUN: llvm-lto2 run -o %t.o %t.bc %t-import.bc %t3.bc -cache-dir %t.cache -r=%t.bc,f1,plx -r=%t.bc,f2,plx -r=%t.bc,f1_actual,plx -r=%t3.bc,vt2a,plx -r=%t3.bc,vt2b,plx -r=%t-import.bc,importf1,plx -r=%t-import.bc,f1,lx -r=%t-import.bc,importf2,plx -r=%t-import.bc,f2,lx ; RUN: llvm-lto2 run -o %t.o %t.bc %t-import.bc %t3.bc -cache-dir %t.cache -r=%t.bc,f1,plx -r=%t.bc,f2,plx -r=%t.bc,f1_actual,plx -r=%t3.bc,vt2a,plx -r=%t3.bc,vt2b,plx -r=%t-import.bc,importf1,plx -r=%t-import.bc,f1,lx -r=%t-import.bc,importf2,plx -r=%t-import.bc,f2,lx
; RUN: ls %t.cache | count 6 ; RUN: ls %t.cache | count 6
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@f1 = alias i1(i8*), i1 (i8*)* @f1_actual @f1 = alias i1(i8*), i1 (i8*)* @f1_actual
define i1 @f1_actual(i8* %p) { define i1 @f1_actual(i8* %p) {
%x = call i1 @llvm.type.test(i8* %p, metadata !"typeid1") %x = call i1 @llvm.type.test(i8* %p, metadata !"typeid1")
ret i1 %x ret i1 %x
} }
Show All 16 Lines

llvm/test/ThinLTO/X86/cache.ll

Show First 20 Lines • Show All 154 Lines • ▼ Show 20 Lines
; RUN: touch -t 198002051200 %t.cache/llvmcache-foo-76 ; RUN: touch -t 198002051200 %t.cache/llvmcache-foo-76
; RUN: llvm-lto -thinlto-action=run -exported-symbol=globalfunc %t2.bc %t.bc -thinlto-cache-dir %t.cache --thinlto-cache-max-size-files 4 --thinlto-cache-entry-expiration 4294967295 ; RUN: llvm-lto -thinlto-action=run -exported-symbol=globalfunc %t2.bc %t.bc -thinlto-cache-dir %t.cache --thinlto-cache-max-size-files 4 --thinlto-cache-entry-expiration 4294967295
; RUN: ls %t.cache/llvmcache-foo-75 ; RUN: ls %t.cache/llvmcache-foo-75
; RUN: ls %t.cache/llvmcache-foo-76 ; RUN: ls %t.cache/llvmcache-foo-76
; RUN: not ls %t.cache/llvmcache-foo-15 ; RUN: not ls %t.cache/llvmcache-foo-15
; RUN: not ls %t.cache/llvmcache-foo-1024 ; RUN: not ls %t.cache/llvmcache-foo-1024
; RUN: not ls %t.cache/llvmcache-foo-7 ; RUN: not ls %t.cache/llvmcache-foo-7
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define void @globalfunc() #0 { define void @globalfunc() #0 {
entry: entry:
ret void ret void
} }

llvm/test/ThinLTO/X86/callees-metadata.ll

; Do setup work: generate bitcode and combined index ; Do setup work: generate bitcode and combined index
; RUN: opt -module-summary %s -o %t1.bc ; RUN: opt -module-summary %s -o %t1.bc
; RUN: opt -module-summary %p/Inputs/callees-metadata.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/callees-metadata.ll -o %t2.bc
; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t.o -save-temps \ ; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t.o -save-temps \
; RUN: -r=%t1.bc,bar,plx \ ; RUN: -r=%t1.bc,bar,plx \
; RUN: -r=%t1.bc,foo,l \ ; RUN: -r=%t1.bc,foo,l \
; RUN: -r=%t2.bc,foo,pl ; RUN: -r=%t2.bc,foo,pl
; RUN: llvm-dis %t.o.1.3.import.bc -o - | FileCheck %s ; RUN: llvm-dis %t.o.1.3.import.bc -o - | FileCheck %s
; CHECK: define {{.*}} i32 @f1.llvm.0 ; CHECK: define {{.*}} i32 @f1.llvm.0
; CHECK: define {{.*}} i32 @f2.llvm.0 ; CHECK: define {{.*}} i32 @f2.llvm.0
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define dso_local i32 @bar(i32 %x) { define dso_local i32 @bar(i32 %x) {
entry: entry:
%call = call i32 @foo(i32 %x) %call = call i32 @foo(i32 %x)
ret i32 %call ret i32 %call
} }
declare dso_local i32 @foo(i32) declare dso_local i32 @foo(i32)

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

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
; RUN: -r=%t.o,_ZTV1C, \ ; RUN: -r=%t.o,_ZTV1C, \
; RUN: -r=%t.o,_ZN1A1nEi, \ ; RUN: -r=%t.o,_ZN1A1nEi, \
; RUN: -r=%t.o,_ZN1B1fEi, \ ; RUN: -r=%t.o,_ZN1B1fEi, \
; RUN: -r=%t.o,_ZN1C1fEi, \ ; RUN: -r=%t.o,_ZN1C1fEi, \
; RUN: -r=%t.o,_ZTV1B,px \ ; RUN: -r=%t.o,_ZTV1B,px \
; RUN: -r=%t.o,_ZTV1C,px 2>&1 | FileCheck %s --check-prefix=ERROR ; RUN: -r=%t.o,_ZTV1C,px 2>&1 | FileCheck %s --check-prefix=ERROR
; ERROR: failed: inconsistent LTO Unit splitting (recompile with -fsplit-lto-unit) ; ERROR: failed: inconsistent LTO Unit splitting (recompile with -fsplit-lto-unit)
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
%struct.A = type { i32 (...)** } %struct.A = type { i32 (...)** }
%struct.B = type { %struct.A } %struct.B = type { %struct.A }
%struct.C = type { %struct.A } %struct.C = type { %struct.A }
@_ZTV1B = constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* undef, i8* bitcast (i32 (%struct.B*, i32)* @_ZN1B1fEi to i8*), i8* bitcast (i32 (%struct.A*, i32)* @_ZN1A1nEi to i8*)] }, !type !0, !type !1 @_ZTV1B = constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* undef, i8* bitcast (i32 (%struct.B*, i32)* @_ZN1B1fEi to i8*), i8* bitcast (i32 (%struct.A*, i32)* @_ZN1A1nEi to i8*)] }, !type !0, !type !1
@_ZTV1C = constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* undef, i8* bitcast (i32 (%struct.C*, i32)* @_ZN1C1fEi to i8*), i8* bitcast (i32 (%struct.A*, i32)* @_ZN1A1nEi to i8*)] }, !type !0, !type !2 @_ZTV1C = constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* undef, i8* bitcast (i32 (%struct.C*, i32)* @_ZN1C1fEi to i8*), i8* bitcast (i32 (%struct.A*, i32)* @_ZN1A1nEi to i8*)] }, !type !0, !type !2
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

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

Show All 34 Lines
; INDEX1: typeid: (name: "_ZTS1A3" ; INDEX1: typeid: (name: "_ZTS1A3"
; The second index file, should only contain the type IDs used in @test1 and @test2. ; The second index file, should only contain the type IDs used in @test1 and @test2.
; RUN: llvm-dis %t2.o.thinlto.bc -o - | FileCheck %s --check-prefix=INDEX2 ; RUN: llvm-dis %t2.o.thinlto.bc -o - | FileCheck %s --check-prefix=INDEX2
; INDEX2-NOT: typeid: (name: "_ZTS1A" ; INDEX2-NOT: typeid: (name: "_ZTS1A"
; INDEX2: typeid: (name: "_ZTS1A2" ; INDEX2: typeid: (name: "_ZTS1A2"
; INDEX2: typeid: (name: "_ZTS1A3" ; INDEX2: typeid: (name: "_ZTS1A3"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
%struct.B = type { %struct.A } %struct.B = type { %struct.A }
%struct.A = type { i32 (...)** } %struct.A = type { i32 (...)** }
@_ZTV1B = constant { [3 x i8*] } { [3 x i8*] [i8* undef, i8* undef, i8* undef] }, !type !0 @_ZTV1B = constant { [3 x i8*] } { [3 x i8*] [i8* undef, i8* undef, i8* undef] }, !type !0
define void @test(i8* %b) { define void @test(i8* %b) {
Show All 23 Lines

llvm/test/ThinLTO/X86/cfi-icall-only-defuse.ll

; Verifies that only functions defined or used by each module make it into the ; Verifies that only functions defined or used by each module make it into the
; CFI functions sets in that module's distributed index. ; CFI functions sets in that module's distributed index.
; RUN: opt -thinlto-bc -thinlto-split-lto-unit %s -o %t1.bc ; RUN: opt -thinlto-bc -thinlto-split-lto-unit %s -o %t1.bc
; RUN: opt -thinlto-bc -thinlto-split-lto-unit %S/Inputs/cfi-icall-only-bazqux.ll -o %t2.bc ; RUN: opt -thinlto-bc -thinlto-split-lto-unit %S/Inputs/cfi-icall-only-bazqux.ll -o %t2.bc
; RUN: llvm-lto2 run -thinlto-distributed-indexes %t1.bc %t2.bc -o %t.out \ ; RUN: llvm-lto2 run -thinlto-distributed-indexes %t1.bc %t2.bc -o %t.out \
; RUN: -r %t1.bc,bar,plx \ ; RUN: -r %t1.bc,bar,plx \
; RUN: -r %t1.bc,baz,x \ ; RUN: -r %t1.bc,baz,x \
; RUN: -r %t1.bc,f,plx \ ; RUN: -r %t1.bc,f,plx \
; RUN: -r %t1.bc,foo,plx \ ; RUN: -r %t1.bc,foo,plx \
; RUN: -r %t2.bc,bar,x \ ; RUN: -r %t2.bc,bar,x \
; RUN: -r %t2.bc,baz,plx \ ; RUN: -r %t2.bc,baz,plx \
; RUN: -r %t2.bc,g,plx \ ; RUN: -r %t2.bc,g,plx \
; RUN: -r %t2.bc,qux,plx ; RUN: -r %t2.bc,qux,plx
; RUN: llvm-bcanalyzer -dump %t1.bc.thinlto.bc | FileCheck %s --check-prefix=FOOBAZ ; RUN: llvm-bcanalyzer -dump %t1.bc.thinlto.bc | FileCheck %s --check-prefix=FOOBAZ
; RUN: llvm-bcanalyzer -dump %t2.bc.thinlto.bc | FileCheck %s --check-prefix=BARQUX ; RUN: llvm-bcanalyzer -dump %t2.bc.thinlto.bc | FileCheck %s --check-prefix=BARQUX
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare !type !0 i8 @baz(i8*) declare !type !0 i8 @baz(i8*)
declare i1 @llvm.type.test(i8* %ptr, metadata %type) nounwind readnone declare i1 @llvm.type.test(i8* %ptr, metadata %type) nounwind readnone
define i8 @foo(i8* %p) !type !0 { define i8 @foo(i8* %p) !type !0 {
%x = call i1 @llvm.type.test(i8* %p, metadata !"t1") %x = call i1 @llvm.type.test(i8* %p, metadata !"t1")
%1 = select i1 %x, i8 0, i8 1 %1 = select i1 %x, i8 0, i8 1
Show All 31 Lines

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

; RUN: opt -thinlto-bc -thinlto-split-lto-unit %s -o %t1.bc ; RUN: opt -thinlto-bc -thinlto-split-lto-unit %s -o %t1.bc
; RUN: llvm-lto2 run -thinlto-distributed-indexes %t1.bc -o %t.out -save-temps \ ; RUN: llvm-lto2 run -thinlto-distributed-indexes %t1.bc -o %t.out -save-temps \
; RUN: -r %t1.bc,foo,plx \ ; RUN: -r %t1.bc,foo,plx \
; RUN: -r %t1.bc,bar,x \ ; RUN: -r %t1.bc,bar,x \
; RUN: -r %t1.bc,addrtaken,px ; RUN: -r %t1.bc,addrtaken,px
; RUN: llvm-bcanalyzer -dump %t.out.index.bc | FileCheck %s --check-prefix=COMBINED ; RUN: llvm-bcanalyzer -dump %t.out.index.bc | FileCheck %s --check-prefix=COMBINED
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i1 @foo(i8* %p) !type !0 { define i1 @foo(i8* %p) !type !0 {
entry: entry:
%x = call i1 @llvm.type.test(i8* %p, metadata !"typeid1") %x = call i1 @llvm.type.test(i8* %p, metadata !"typeid1")
ret i1 %x ret i1 %x
} }
Show All 21 Lines

llvm/test/ThinLTO/X86/cfi.ll

Show All 16 Lines
; RUN: llvm-lto2 run -save-temps %t.o -use-new-pm \ ; RUN: llvm-lto2 run -save-temps %t.o -use-new-pm \
; RUN: -o %t3 \ ; RUN: -o %t3 \
; RUN: -r=%t.o,test,px \ ; RUN: -r=%t.o,test,px \
; RUN: -r=%t.o,_ZTV1B, \ ; RUN: -r=%t.o,_ZTV1B, \
; RUN: -r=%t.o,_ZN1B1fEi, \ ; RUN: -r=%t.o,_ZN1B1fEi, \
; RUN: -r=%t.o,_ZTV1B,px ; RUN: -r=%t.o,_ZTV1B,px
; RUN: llvm-dis %t3.1.4.opt.bc -o - | FileCheck %s --check-prefix=CHECK-IR ; RUN: llvm-dis %t3.1.4.opt.bc -o - | FileCheck %s --check-prefix=CHECK-IR
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
%struct.B = type { %struct.A } %struct.B = type { %struct.A }
%struct.A = type { i32 (...)** } %struct.A = type { i32 (...)** }
@_ZTV1B = constant { [3 x i8*] } { [3 x i8*] [i8* undef, i8* undef, i8* undef] }, !type !0 @_ZTV1B = constant { [3 x i8*] } { [3 x i8*] [i8* undef, i8* undef, i8* undef] }, !type !0
; CHECK-IR-LABEL: define void @test ; CHECK-IR-LABEL: define void @test
Show All 27 Lines

llvm/test/ThinLTO/X86/crash_debuginfo.ll

; RUN: opt -module-summary -o %t-dst.bc %s ; RUN: opt -module-summary -o %t-dst.bc %s
; RUN: opt -module-summary -o %t-src.bc %p/Inputs/crash_debuginfo.ll ; RUN: opt -module-summary -o %t-src.bc %p/Inputs/crash_debuginfo.ll
; RUN: llvm-lto -thinlto -o %t-index %t-dst.bc %t-src.bc ; RUN: llvm-lto -thinlto -o %t-index %t-dst.bc %t-src.bc
; RUN: opt -function-import -inline -summary-file %t-index.thinlto.bc %t-dst.bc -o %t.out ; RUN: opt -function-import -inline -summary-file %t-index.thinlto.bc %t-dst.bc -o %t.out
; RUN: llvm-nm %t.out | FileCheck %s ; RUN: llvm-nm %t.out | FileCheck %s
; Verify that we import bar and inline it. It use to crash importing due to ODR type uniquing ; Verify that we import bar and inline it. It use to crash importing due to ODR type uniquing
; CHECK-NOT: bar ; CHECK-NOT: bar
; CHECK: foo ; CHECK: foo
; CHECK-NOT: bar ; CHECK-NOT: bar
; ModuleID = 'test/ThinLTO/X86/crash_debuginfo.ll' ; ModuleID = 'test/ThinLTO/X86/crash_debuginfo.ll'
source_filename = "test/ThinLTO/X86/crash_debuginfo.ll" source_filename = "test/ThinLTO/X86/crash_debuginfo.ll"
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
define void @foo(i32 %arg) { define void @foo(i32 %arg) {
call void @bar(i32 %arg), !dbg !8 call void @bar(i32 %arg), !dbg !8
unreachable unreachable
} }
declare void @bar(i32) declare void @bar(i32)
Show All 23 Lines

llvm/test/ThinLTO/X86/deadstrip.ll

Show First 20 Lines • Show All 126 Lines • ▼ Show 20 Lines
; We can't internalize @dead_func because of the use in the regular LTO ; We can't internalize @dead_func because of the use in the regular LTO
; partition. ; partition.
; CHECK-NOTDEAD: define dso_local void @dead_func() ; CHECK-NOTDEAD: define dso_local void @dead_func()
; We also can't eliminate @baz because it is in the regular LTO partition ; We also can't eliminate @baz because it is in the regular LTO partition
; and called from @dead_func. ; and called from @dead_func.
; CHECK-NM-NOTDEAD: T _baz ; CHECK-NM-NOTDEAD: T _baz
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__I_a, i8* null }] @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__I_a, i8* null }]
declare void @baz() declare void @baz()
declare void @boo() declare void @boo()
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

llvm/test/ThinLTO/X86/debuginfo-compositetype-import.ll

Show All 28 Lines
; FULL: distinct !DICompositeType(tag: DW_TAG_enumeration_type, name: "enum", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: 50, size: 32, elements: !{{[0-9]+}}, identifier: "enum") ; FULL: distinct !DICompositeType(tag: DW_TAG_enumeration_type, name: "enum", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: 50, size: 32, elements: !{{[0-9]+}}, identifier: "enum")
; FULL: distinct !DICompositeType(tag: DW_TAG_class_type, name: "class", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: 728, size: 448, elements: !{{[0-9]+}}, identifier: "class") ; FULL: distinct !DICompositeType(tag: DW_TAG_class_type, name: "class", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: 728, size: 448, elements: !{{[0-9]+}}, identifier: "class")
; FULL: distinct !DICompositeType(tag: DW_TAG_structure_type, name: "struct", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: 309, baseType: !{{[0-9]+}}, size: 128, offset: 64, elements: !{{[0-9]+}}, vtableHolder: !{{[0-9]+}}, templateParams: !{{[0-9]+}}, identifier: "list") ; FULL: distinct !DICompositeType(tag: DW_TAG_structure_type, name: "struct", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: 309, baseType: !{{[0-9]+}}, size: 128, offset: 64, elements: !{{[0-9]+}}, vtableHolder: !{{[0-9]+}}, templateParams: !{{[0-9]+}}, identifier: "list")
; FULL: distinct !DICompositeType(tag: DW_TAG_union_type, file: !{{[0-9]+}}, line: 115, size: 384, elements: !{{[0-9]+}}, identifier: "union") ; FULL: distinct !DICompositeType(tag: DW_TAG_union_type, file: !{{[0-9]+}}, line: 115, size: 384, elements: !{{[0-9]+}}, identifier: "union")
; ModuleID = 'debuginfo-compositetype-import.c' ; ModuleID = 'debuginfo-compositetype-import.c'
source_filename = "debuginfo-compositetype-import.c" source_filename = "debuginfo-compositetype-import.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @foo() #0 !dbg !6 { define void @foo() #0 !dbg !6 {
entry: entry:
ret void ret void
} }
Show All 17 Lines

llvm/test/ThinLTO/X86/debuginfo-cu-import.ll

Show All 11 Lines
; CHECK-NOT: DICompileUnit{{.*}} macros: ; CHECK-NOT: DICompileUnit{{.*}} macros:
; CHECK-NOT: DICompileUnit{{.*}} retainedTypes: ; CHECK-NOT: DICompileUnit{{.*}} retainedTypes:
; CHECK-NOT: DICompileUnit{{.*}} globals: ; CHECK-NOT: DICompileUnit{{.*}} globals:
; CHECK: DICompileUnit{{.*}} imports: ![[IMP:[0-9]+]] ; CHECK: DICompileUnit{{.*}} imports: ![[IMP:[0-9]+]]
; CHECK: ![[IMP]] = !{!{{[0-9]+}}} ; CHECK: ![[IMP]] = !{!{{[0-9]+}}}
; ModuleID = 'debuginfo-cu-import.c' ; ModuleID = 'debuginfo-cu-import.c'
source_filename = "debuginfo-cu-import.c" source_filename = "debuginfo-cu-import.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @foo() !dbg !28 { define void @foo() !dbg !28 {
entry: entry:
ret void, !dbg !29 ret void, !dbg !29
} }
define void @_ZN1A1aEv() !dbg !13 { define void @_ZN1A1aEv() !dbg !13 {
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Lines
; RUN: -r=%t.o,_ZTV1B,px 2>&1 | FileCheck %s --check-prefix=REMARK ; RUN: -r=%t.o,_ZTV1B,px 2>&1 | FileCheck %s --check-prefix=REMARK
; RUN: llvm-dis %t3.1.4.opt.bc -o - | FileCheck %s --check-prefix=CHECK-IR ; RUN: llvm-dis %t3.1.4.opt.bc -o - | FileCheck %s --check-prefix=CHECK-IR
; We should only devirtualize the inlined call to bar(). ; We should only devirtualize the inlined call to bar().
; REMARK-NOT: single-impl: devirtualized a call to _ZN1B3fooEv ; REMARK-NOT: single-impl: devirtualized a call to _ZN1B3fooEv
; REMARK: single-impl: devirtualized a call to _ZN1B3barEv ; REMARK: single-impl: devirtualized a call to _ZN1B3barEv
; REMARK-NOT: single-impl: devirtualized a call to _ZN1B3fooEv ; REMARK-NOT: single-impl: devirtualized a call to _ZN1B3fooEv
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
%class.A = type { i32 (...)** } %class.A = type { i32 (...)** }
%class.B = type { %class.A } %class.B = type { %class.A }
@_ZTV1A = linkonce_odr hidden unnamed_addr constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* undef, i8* bitcast (i32 (%class.A*)* @_ZN1A3fooEv to i8*), i8* bitcast (i32 (%class.A*)* @_ZN1A3barEv to i8*)] }, align 8, !type !0 @_ZTV1A = linkonce_odr hidden unnamed_addr constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* undef, i8* bitcast (i32 (%class.A*)* @_ZN1A3fooEv to i8*), i8* bitcast (i32 (%class.A*)* @_ZN1A3barEv to i8*)] }, align 8, !type !0
@_ZTV1B = hidden unnamed_addr constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* undef, i8* bitcast (i32 (%class.B*)* @_ZN1B3fooEv to i8*), i8* bitcast (i32 (%class.B*)* @_ZN1B3barEv to i8*)] }, align 8, !type !0, !type !1 @_ZTV1B = hidden unnamed_addr constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* undef, i8* bitcast (i32 (%class.B*)* @_ZN1B3fooEv to i8*), i8* bitcast (i32 (%class.B*)* @_ZN1B3barEv to i8*)] }, align 8, !type !0, !type !1
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/test/ThinLTO/X86/devirt.ll

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 Lines
; RUN: -r=%t.o,_ZTV1B,px \ ; RUN: -r=%t.o,_ZTV1B,px \
; RUN: -r=%t.o,_ZTV1C,px \ ; RUN: -r=%t.o,_ZTV1C,px \
; RUN: -r=%t.o,_ZTV1D,px 2>&1 | FileCheck %s --check-prefix=REMARK --dump-input=fail ; RUN: -r=%t.o,_ZTV1D,px 2>&1 | FileCheck %s --check-prefix=REMARK --dump-input=fail
; RUN: llvm-dis %t3.1.4.opt.bc -o - | FileCheck %s --check-prefix=CHECK-IR ; RUN: llvm-dis %t3.1.4.opt.bc -o - | FileCheck %s --check-prefix=CHECK-IR
; REMARK-DAG: single-impl: devirtualized a call to _ZN1A1nEi ; REMARK-DAG: single-impl: devirtualized a call to _ZN1A1nEi
; REMARK-DAG: single-impl: devirtualized a call to _ZN1D1mEi ; REMARK-DAG: single-impl: devirtualized a call to _ZN1D1mEi
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
%struct.A = type { i32 (...)** } %struct.A = type { i32 (...)** }
%struct.B = type { %struct.A } %struct.B = type { %struct.A }
%struct.C = type { %struct.A } %struct.C = type { %struct.A }
%struct.D = type { i32 (...)** } %struct.D = type { i32 (...)** }
@_ZTV1B = constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* undef, i8* bitcast (i32 (%struct.B*, i32)* @_ZN1B1fEi to i8*), i8* bitcast (i32 (%struct.A*, i32)* @_ZN1A1nEi to i8*)] }, !type !0, !type !1 @_ZTV1B = constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* undef, i8* bitcast (i32 (%struct.B*, i32)* @_ZN1B1fEi to i8*), i8* bitcast (i32 (%struct.A*, i32)* @_ZN1A1nEi to i8*)] }, !type !0, !type !1
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

llvm/test/ThinLTO/X86/devirt2.ll

Show First 20 Lines • Show All 194 Lines • ▼ Show 20 Lines
; REMARK-DAG: single-impl: devirtualized a call to _ZN1A1nEi ; REMARK-DAG: single-impl: devirtualized a call to _ZN1A1nEi
; REMARK-DAG: single-impl: devirtualized a call to _ZN1D1mEi ; REMARK-DAG: single-impl: devirtualized a call to _ZN1D1mEi
; We should devirt call to _ZN1E1mEi once in importing module and once ; We should devirt call to _ZN1E1mEi once in importing module and once
; in original (exporting) module. ; in original (exporting) module.
; REMARK-DAG: single-impl: devirtualized a call to _ZN1E1mEi ; REMARK-DAG: single-impl: devirtualized a call to _ZN1E1mEi
; REMARK-DAG: single-impl: devirtualized a call to _ZN1E1mEi ; REMARK-DAG: single-impl: devirtualized a call to _ZN1E1mEi
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
%struct.A = type { i32 (...)** } %struct.A = type { i32 (...)** }
%struct.B = type { %struct.A } %struct.B = type { %struct.A }
%struct.C = type { %struct.A } %struct.C = type { %struct.A }
%struct.D = type { i32 (...)** } %struct.D = type { i32 (...)** }
%struct.E = type { i32 (...)** } %struct.E = type { i32 (...)** }
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

llvm/test/ThinLTO/X86/diagnostic-handler-remarks-with-hotness.ll

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
; YAML2-NEXT: - String: '(cost=' ; YAML2-NEXT: - String: '(cost='
; YAML2-NEXT: - Cost: '-30' ; YAML2-NEXT: - Cost: '-30'
; YAML2-NEXT: - String: ', threshold=' ; YAML2-NEXT: - String: ', threshold='
; YAML2-NEXT: - Threshold: '337' ; YAML2-NEXT: - Threshold: '337'
; YAML2-NEXT: - String: ')' ; YAML2-NEXT: - String: ')'
; YAML2-NEXT: ... ; YAML2-NEXT: ...
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define i32 @bar() { define i32 @bar() {
ret i32 42 ret i32 42
} }
declare i32 @foo() declare i32 @foo()
define i32 @main() !prof !0 { define i32 @main() !prof !0 {
%i = call i32 @foo() %i = call i32 @foo()
ret i32 %i ret i32 %i
} }
!0 = !{!"function_entry_count", i64 50} !0 = !{!"function_entry_count", i64 50}

llvm/test/ThinLTO/X86/diagnostic-handler-remarks.ll

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
; YAML2-NEXT: - String: '(cost=' ; YAML2-NEXT: - String: '(cost='
; YAML2-NEXT: - Cost: '-30' ; YAML2-NEXT: - Cost: '-30'
; YAML2-NEXT: - String: ', threshold=' ; YAML2-NEXT: - String: ', threshold='
; YAML2-NEXT: - Threshold: '337' ; YAML2-NEXT: - Threshold: '337'
; YAML2-NEXT: - String: ')' ; YAML2-NEXT: - String: ')'
; YAML2-NEXT: ... ; YAML2-NEXT: ...
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define i32 @bar() { define i32 @bar() {
ret i32 42 ret i32 42
} }
declare i32 @foo() declare i32 @foo()
define i32 @main() { define i32 @main() {
%i = call i32 @foo() %i = call i32 @foo()
ret i32 %i ret i32 %i
} }

llvm/test/ThinLTO/X86/dicompositetype-unique-alias.ll

Show All 14 Lines
; Only llvm-lto2 adds the dso_local keyword, hence the {{.*}} ; Only llvm-lto2 adds the dso_local keyword, hence the {{.*}}
; CHECK: define available_externally{{.*}} void @_ZN4CFVSD1Ev ; CHECK: define available_externally{{.*}} void @_ZN4CFVSD1Ev
; Confirm that we only have a single DICompositeType after importing ; Confirm that we only have a single DICompositeType after importing
; both an alias and its aliasee, since ODR Type Uniquing is enabled. ; both an alias and its aliasee, since ODR Type Uniquing is enabled.
; CHECK: DICompositeType ; CHECK: DICompositeType
; CHECK-NOT: DICompositeType ; CHECK-NOT: DICompositeType
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-scei-ps4" target triple = "x86_64-scei-ps4"
%class.C = type <{ i32 (...)**, %class.A, %struct.CFVS, [6 x i8] }> %class.C = type <{ i32 (...)**, %class.A, %struct.CFVS, [6 x i8] }>
%class.A = type { %struct.Vec } %class.A = type { %struct.Vec }
%struct.Vec = type { i8 } %struct.Vec = type { i8 }
%struct.CFVS = type { %struct.Vec } %struct.CFVS = type { %struct.Vec }
%struct.S = type { i8 } %struct.S = type { i8 }
Show All 31 Lines

llvm/test/ThinLTO/X86/dicompositetype-unique.ll

; RUN: opt -module-summary -o %t1.bc %s ; RUN: opt -module-summary -o %t1.bc %s
; RUN: opt -module-summary -o %t2.bc %S/Inputs/dicompositetype-unique.ll ; RUN: opt -module-summary -o %t2.bc %S/Inputs/dicompositetype-unique.ll
; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t --save-temps \ ; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t --save-temps \
; RUN: -r %t1.bc,_foo,lx \ ; RUN: -r %t1.bc,_foo,lx \
; RUN: -r %t1.bc,_main,plx \ ; RUN: -r %t1.bc,_main,plx \
; RUN: -r %t2.bc,_foo,plx ; RUN: -r %t2.bc,_foo,plx
; RUN: llvm-dis %t.1.3.import.bc -o - | FileCheck %s ; RUN: llvm-dis %t.1.3.import.bc -o - | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
declare void @foo() declare void @foo()
define i32 @main() { define i32 @main() {
call void @foo() call void @foo()
ret i32 0 ret i32 0
} }
Show All 12 Lines

llvm/test/ThinLTO/X86/dicompositetype-unique2.ll

; RUN: opt -module-summary -o %t1.bc %s ; RUN: opt -module-summary -o %t1.bc %s
; RUN: opt -module-summary -o %t2.bc %S/Inputs/dicompositetype-unique2.ll ; RUN: opt -module-summary -o %t2.bc %S/Inputs/dicompositetype-unique2.ll
; RUN: llvm-lto --thinlto-action=run %t1.bc %t2.bc -thinlto-save-temps=%t3. ; RUN: llvm-lto --thinlto-action=run %t1.bc %t2.bc -thinlto-save-temps=%t3.
; RUN: llvm-dis %t3.0.3.imported.bc -o - | FileCheck %s ; RUN: llvm-dis %t3.0.3.imported.bc -o - | FileCheck %s
; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t --save-temps \ ; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t --save-temps \
; RUN: -r %t1.bc,_ZN1CD2Ev,pl \ ; RUN: -r %t1.bc,_ZN1CD2Ev,pl \
; RUN: -r %t1.bc,_ZN4CFVSD2Ev,l \ ; RUN: -r %t1.bc,_ZN4CFVSD2Ev,l \
; RUN: -r %t1.bc,_Z3Getv,l \ ; RUN: -r %t1.bc,_Z3Getv,l \
; RUN: -r %t2.bc,_ZN4CFVSD2Ev,pl \ ; RUN: -r %t2.bc,_ZN4CFVSD2Ev,pl \
; RUN: -r %t2.bc,_Z3Getv,l ; RUN: -r %t2.bc,_Z3Getv,l
; RUN: llvm-dis %t.1.3.import.bc -o - | FileCheck %s ; RUN: llvm-dis %t.1.3.import.bc -o - | FileCheck %s
; Only llvm-lto2 adds the dso_local keyword, hence the {{.*}} ; Only llvm-lto2 adds the dso_local keyword, hence the {{.*}}
; CHECK: define available_externally{{.*}} void @_ZN4CFVSD2Ev ; CHECK: define available_externally{{.*}} void @_ZN4CFVSD2Ev
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-scei-ps4" target triple = "x86_64-scei-ps4"
%class.C = type <{ i32 (...)**, %class.A, %struct.CFVS, [6 x i8] }> %class.C = type <{ i32 (...)**, %class.A, %struct.CFVS, [6 x i8] }>
%class.A = type { %struct.Vec } %class.A = type { %struct.Vec }
%struct.Vec = type { i8 } %struct.Vec = type { i8 }
%struct.CFVS = type { %struct.Vec } %struct.CFVS = type { %struct.Vec }
%struct.S = type { i8 } %struct.S = type { i8 }
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/ThinLTO/X86/distributed_import.ll

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
; RUN: llvm-dis -o - %t1.out | FileCheck %s --check-prefix=IMPORT ; RUN: llvm-dis -o - %t1.out | FileCheck %s --check-prefix=IMPORT
; RUN: llvm-dis -o - %t2.out | FileCheck %s --check-prefix=EXPORT ; RUN: llvm-dis -o - %t2.out | FileCheck %s --check-prefix=EXPORT
; IMPORT: define available_externally i32 @g() !thinlto_src_module ; IMPORT: define available_externally i32 @g() !thinlto_src_module
; IMPORT: define available_externally void @analias() !thinlto_src_module ; IMPORT: define available_externally void @analias() !thinlto_src_module
; EXPORT: @G.llvm. ; EXPORT: @G.llvm.
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
declare i32 @g(...) declare i32 @g(...)
declare void @analias(...) declare void @analias(...)
define void @f() { define void @f() {
entry: entry:
call i32 (...) @g() call i32 (...) @g()
call void (...) @analias() call void (...) @analias()
Show All 26 Lines

llvm/test/ThinLTO/X86/dot-dumper-full-lto.ll

; RUN: opt -module-summary %s -o %t1.bc ; RUN: opt -module-summary %s -o %t1.bc
; RUN: opt -module-summary %p/Inputs/dot-dumper.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/dot-dumper.ll -o %t2.bc
; RUN: llvm-lto2 run -save-temps %t1.bc %t2.bc -o %t3 \ ; RUN: llvm-lto2 run -save-temps %t1.bc %t2.bc -o %t3 \
; RUN: -r=%t1.bc,main,px \ ; RUN: -r=%t1.bc,main,px \
; RUN: -r=%t1.bc,A, \ ; RUN: -r=%t1.bc,A, \
; RUN: -r=%t2.bc,foo,p \ ; RUN: -r=%t2.bc,foo,p \
; RUN: -r=%t2.bc,bar,p \ ; RUN: -r=%t2.bc,bar,p \
; RUN: -r=%t2.bc,A,p \ ; RUN: -r=%t2.bc,A,p \
; RUN: -r=%t2.bc,B,p ; RUN: -r=%t2.bc,B,p
; RUN: cat %t3.index.dot | FileCheck %s ; RUN: cat %t3.index.dot | FileCheck %s
; CHECK: subgraph cluster_4294967295 ; CHECK: subgraph cluster_4294967295
; CHECK: M4294967295_[[ID:[0-9]+]]{{.*}}main ; CHECK: M4294967295_[[ID:[0-9]+]]{{.*}}main
; CHECK: // Cross-module edges: ; CHECK: // Cross-module edges:
; CHECK: M4294967295_[[ID]] -> M0_{{[0-9]+}}{{.*}}// ref ; CHECK: M4294967295_[[ID]] -> M0_{{[0-9]+}}{{.*}}// ref
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@A = external global i32 @A = external global i32
define i32 @main() { define i32 @main() {
%v = load i32, i32* @A %v = load i32, i32* @A
ret i32 %v ret i32 %v
} }
!0 = !{i32 1, !"ThinLTO", i32 0} !0 = !{i32 1, !"ThinLTO", i32 0}
!llvm.module.flags = !{ !0 } !llvm.module.flags = !{ !0 }

llvm/test/ThinLTO/X86/dot-dumper.ll

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
; COMBINED-NEXT: M1_[[FOO]] -> M1_[[B]] [style=dashed,color=forestgreen]; // const-ref ; COMBINED-NEXT: M1_[[FOO]] -> M1_[[B]] [style=dashed,color=forestgreen]; // const-ref
; COMBINED-NEXT: M1_[[FOO]] -> M1_[[A]] [style=dashed,color=forestgreen]; // const-ref ; COMBINED-NEXT: M1_[[FOO]] -> M1_[[A]] [style=dashed,color=forestgreen]; // const-ref
; COMBINED-NEXT: } ; COMBINED-NEXT: }
; COMBINED-NEXT: // Cross-module edges: ; COMBINED-NEXT: // Cross-module edges:
; COMBINED-NEXT: M0_[[MAIN]] -> M1_[[A]] [style=dashed,color=forestgreen]; // const-ref ; COMBINED-NEXT: M0_[[MAIN]] -> M1_[[A]] [style=dashed,color=forestgreen]; // const-ref
; COMBINED-NEXT: M0_[[MAIN]] -> M1_[[FOO]] // call (hotness : Unknown) ; COMBINED-NEXT: M0_[[MAIN]] -> M1_[[FOO]] // call (hotness : Unknown)
; COMBINED-NEXT: } ; COMBINED-NEXT: }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@A = external local_unnamed_addr global i32, align 4 @A = external local_unnamed_addr global i32, align 4
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define i32 @main() local_unnamed_addr { define i32 @main() local_unnamed_addr {
%1 = tail call i32 (...) @foo() %1 = tail call i32 (...) @foo()
%2 = load i32, i32* @A, align 4 %2 = load i32, i32* @A, align 4
%3 = add nsw i32 %2, %1 %3 = add nsw i32 %2, %1
ret i32 %3 ret i32 %3
} }
@main_alias = weak_odr alias i32 (), i32 ()* @main @main_alias = weak_odr alias i32 (), i32 ()* @main
declare i32 @foo(...) local_unnamed_addr declare i32 @foo(...) local_unnamed_addr

llvm/test/ThinLTO/X86/dot-dumper2.ll

Show All 25 Lines
; COMBINED-NEXT: node [style=filled,fillcolor=lightblue]; ; COMBINED-NEXT: node [style=filled,fillcolor=lightblue];
; COMBINED-NEXT: M1_[[A:[0-9]+]] [shape="Mrecord",label="A|extern}"]; // variable, writeOnly ; COMBINED-NEXT: M1_[[A:[0-9]+]] [shape="Mrecord",label="A|extern}"]; // variable, writeOnly
; COMBINED-NEXT: // Edges: ; COMBINED-NEXT: // Edges:
; COMBINED-NEXT: } ; COMBINED-NEXT: }
; COMBINED-NEXT: // Cross-module edges: ; COMBINED-NEXT: // Cross-module edges:
; COMBINED-NEXT: M0_[[MAIN]] -> M1_[[A]] [style=dashed,color=violetred]; // writeOnly-ref ; COMBINED-NEXT: M0_[[MAIN]] -> M1_[[A]] [style=dashed,color=violetred]; // writeOnly-ref
; COMBINED-NEXT: } ; COMBINED-NEXT: }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@A = external local_unnamed_addr global i32, align 4 @A = external local_unnamed_addr global i32, align 4
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define i32 @main() local_unnamed_addr { define i32 @main() local_unnamed_addr {
store i32 42, i32* @A, align 4 store i32 42, i32* @A, align 4
ret i32 0 ret i32 0
} }

llvm/test/ThinLTO/X86/drop-debug-info.ll

; RUN: opt -module-summary %s -o %t.bc ; RUN: opt -module-summary %s -o %t.bc
; RUN: llvm-lto -thinlto-action=thinlink -o %t.index.bc %t.bc %p/Inputs/drop-debug-info.bc ; RUN: llvm-lto -thinlto-action=thinlink -o %t.index.bc %t.bc %p/Inputs/drop-debug-info.bc
; The imported module has out-of-date debug information, let's make sure we can ; The imported module has out-of-date debug information, let's make sure we can
; drop them without crashing when materializing later. ; drop them without crashing when materializing later.
; RUN: llvm-link %t.bc -summary-index=%t.index.bc -import=globalfunc:%p/Inputs/drop-debug-info.bc | llvm-dis -o - | FileCheck %s ; RUN: llvm-link %t.bc -summary-index=%t.index.bc -import=globalfunc:%p/Inputs/drop-debug-info.bc | llvm-dis -o - | FileCheck %s
; CHECK: define available_externally void @globalfunc ; CHECK: define available_externally void @globalfunc
; CHECK-NOT: llvm.dbg.value ; CHECK-NOT: llvm.dbg.value
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define i32 @main() #0 { define i32 @main() #0 {
entry: entry:
call void (...) @globalfunc() call void (...) @globalfunc()
ret i32 0 ret i32 0
} }
declare void @globalfunc(...) declare void @globalfunc(...)

llvm/test/ThinLTO/X86/dsolocal_dllimport.ll

; RUN: opt -module-summary %s -o %t1.bc ; RUN: opt -module-summary %s -o %t1.bc
; RUN: opt -module-summary %S/Inputs/dsolocal_dllimport.ll -o %t2.bc ; RUN: opt -module-summary %S/Inputs/dsolocal_dllimport.ll -o %t2.bc
; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t -r=%t1.bc,bar,px -r=%t1.bc,__imp_foo, -r=%t2.bc,foo -save-temps ; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t -r=%t1.bc,bar,px -r=%t1.bc,__imp_foo, -r=%t2.bc,foo -save-temps
; RUN: llvm-dis < %t.1.3.import.bc | FileCheck %s ; RUN: llvm-dis < %t.1.3.import.bc | FileCheck %s
; If a user (dllimport) is LTOed with a library, check that we replace dllimport with dso_local. ; If a user (dllimport) is LTOed with a library, check that we replace dllimport with dso_local.
; CHECK: declare dso_local void @foo() ; CHECK: declare dso_local void @foo()
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.11.0" target triple = "x86_64-pc-windows-msvc19.11.0"
define void @bar() { define void @bar() {
call void @foo() call void @foo()
ret void ret void
} }
declare dllimport void @foo() declare dllimport void @foo()

llvm/test/ThinLTO/X86/emit_imports.ll

Show All 38 Lines
; RUN: cat %t2.bc.imports | count 0 ; RUN: cat %t2.bc.imports | count 0
; The imports file for Input/empty.ll is empty but should exist. ; The imports file for Input/empty.ll is empty but should exist.
; RUN: cat %t3.bc.imports | count 0 ; RUN: cat %t3.bc.imports | count 0
; The index file should be created even for the input with an empty summary. ; The index file should be created even for the input with an empty summary.
; RUN: ls %t3.bc.thinlto.bc ; RUN: ls %t3.bc.thinlto.bc
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @g(...) declare void @g(...)
declare void @h(...) declare void @h(...)
define void @f() { define void @f() {
entry: entry:
call void (...) @g() call void (...) @g()
call void (...) @h() call void (...) @h()
ret void ret void
} }

llvm/test/ThinLTO/X86/empty-module.ll

; RUN: opt -module-summary -o %t.bc %s ; RUN: opt -module-summary -o %t.bc %s
; RUN: rm -f %t2.0 ; RUN: rm -f %t2.0
; RUN: llvm-lto2 run %t.bc -r %t.bc,foo,pl -o %t2 -thinlto-distributed-indexes ; RUN: llvm-lto2 run %t.bc -r %t.bc,foo,pl -o %t2 -thinlto-distributed-indexes
; RUN: llvm-readobj -h %t2.0 | FileCheck %s ; RUN: llvm-readobj -h %t2.0 | FileCheck %s
; RUN: llvm-nm %t2.0 2>&1 | FileCheck %s -check-prefix=NO-SYMBOLS ; RUN: llvm-nm %t2.0 2>&1 | FileCheck %s -check-prefix=NO-SYMBOLS
; NO-SYMBOLS: no symbols ; NO-SYMBOLS: no symbols
; CHECK: Format: ELF64-x86-64 ; CHECK: Format: ELF64-x86-64
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foo = ifunc i32 (i32), i64 ()* @foo_ifunc @foo = ifunc i32 (i32), i64 ()* @foo_ifunc
define internal i64 @foo_ifunc() { define internal i64 @foo_ifunc() {
entry: entry:
ret i64 0 ret i64 0
} }

llvm/test/ThinLTO/X86/empty_module_with_cache.ll

Show All 25 Lines
; Verify that caching is disabled for module without hash, with llvm-lto2 ; Verify that caching is disabled for module without hash, with llvm-lto2
; RUN: rm -Rf %t.cache ; RUN: rm -Rf %t.cache
; RUN: llvm-lto2 run -o %t.o %t2.bc %t.bc -cache-dir %t.cache \ ; RUN: llvm-lto2 run -o %t.o %t2.bc %t.bc -cache-dir %t.cache \
; RUN: -r=%t2.bc,_main,plx ; RUN: -r=%t2.bc,_main,plx
; RUN: ls %t.cache | count 0 ; RUN: ls %t.cache | count 0
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"

llvm/test/ThinLTO/X86/export.ll

; Do setup work for all below tests: generate bitcode and combined index ; Do setup work for all below tests: generate bitcode and combined index
; RUN: opt -module-summary %s -o %t1.bc ; RUN: opt -module-summary %s -o %t1.bc
; RUN: opt -module-summary %p/Inputs/export.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/export.ll -o %t2.bc
; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t1.bc %t2.bc ; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t1.bc %t2.bc
; Ensure statics are promoted/renamed correctly from this file. ; Ensure statics are promoted/renamed correctly from this file.
; RUN: llvm-lto -thinlto-action=promote %t1.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s ; RUN: llvm-lto -thinlto-action=promote %t1.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s
; CHECK-DAG: @staticvar.llvm.0 = hidden global ; CHECK-DAG: @staticvar.llvm.0 = hidden global
; CHECK-DAG: define hidden void @staticfunc.llvm.0 ; CHECK-DAG: define hidden void @staticfunc.llvm.0
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
@staticvar = internal global i32 1, align 4 @staticvar = internal global i32 1, align 4
define void @callstaticfunc() #0 { define void @callstaticfunc() #0 {
entry: entry:
call void @staticfunc() call void @staticfunc()
ret void ret void
} }
define internal void @staticfunc() #0 { define internal void @staticfunc() #0 {
entry: entry:
%0 = load i32, i32* @staticvar, align 4 %0 = load i32, i32* @staticvar, align 4
ret void ret void
} }

llvm/test/ThinLTO/X86/funcimport-debug.ll

Show All 15 Lines
; RUN: -thinlto-threads=1 \ ; RUN: -thinlto-threads=1 \
; RUN: -debug-only=function-import 2>&1 | FileCheck %s ; RUN: -debug-only=function-import 2>&1 | FileCheck %s
; CHECK-DAG: Initialize import for 6699318081062747564 (foo) ; CHECK-DAG: Initialize import for 6699318081062747564 (foo)
; CHECK-DAG: Initialize import for 15822663052811949562 (main) ; CHECK-DAG: Initialize import for 15822663052811949562 (main)
; CHECK-DAG: ref -> 7546896869197086323 (baz) ; CHECK-DAG: ref -> 7546896869197086323 (baz)
; CHECK-DAG: edge -> 6699318081062747564 (foo) Threshold:100 ; CHECK-DAG: edge -> 6699318081062747564 (foo) Threshold:100
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define i32 @main() #0 { define i32 @main() #0 {
entry: entry:
call void (...) @foo() call void (...) @foo()
%0 = load i32, i32* @baz, align 4 %0 = load i32, i32* @baz, align 4
ret i32 %0 ret i32 %0
} }
declare void @foo(...) #1 declare void @foo(...) #1
@baz = external global i32 @baz = external global i32

llvm/test/ThinLTO/X86/funcimport-tbaa.ll

; We generate invalid TBAA, hence -disable-verify, but this is a convenient way ; We generate invalid TBAA, hence -disable-verify, but this is a convenient way
; to trigger a metadata lazyloading crash ; to trigger a metadata lazyloading crash
; RUN: opt -module-summary %s -o %t.bc -bitcode-mdindex-threshold=0 -disable-verify ; RUN: opt -module-summary %s -o %t.bc -bitcode-mdindex-threshold=0 -disable-verify
; RUN: opt -module-summary %p/Inputs/funcimport-tbaa.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/funcimport-tbaa.ll -o %t2.bc
; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc ; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc
; RUN: llvm-lto -thinlto-action=import %t2.bc -thinlto-index=%t3.bc -o - \ ; RUN: llvm-lto -thinlto-action=import %t2.bc -thinlto-index=%t3.bc -o - \
; RUN: | llvm-dis -o - | FileCheck %s --check-prefix=IMPORTGLOB1 ; RUN: | llvm-dis -o - | FileCheck %s --check-prefix=IMPORTGLOB1
; IMPORTGLOB1: define available_externally float @globalfunc1 ; IMPORTGLOB1: define available_externally float @globalfunc1
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define float @globalfunc1(i32*, float*) { define float @globalfunc1(i32*, float*) {
%3 = load i32, i32* %0, align 4, !tbaa !0 %3 = load i32, i32* %0, align 4, !tbaa !0
%4 = sitofp i32 %3 to float %4 = sitofp i32 %3 to float
%5 = load float, float* %1, align 4, !tbaa !4 %5 = load float, float* %1, align 4, !tbaa !4
%6 = fadd float %4, %5 %6 = fadd float %4, %5
ret float %6 ret float %6
Show All 17 Lines

llvm/test/ThinLTO/X86/funcimport.ll

Show All 40 Lines
; Verify that all run together ; Verify that all run together
; RUN: llvm-lto -thinlto-action=run %t2.bc %t.bc -exported-symbol=_main ; RUN: llvm-lto -thinlto-action=run %t2.bc %t.bc -exported-symbol=_main
; RUN: llvm-nm -o - < %t.bc.thinlto.o | FileCheck %s --check-prefix=ALL ; RUN: llvm-nm -o - < %t.bc.thinlto.o | FileCheck %s --check-prefix=ALL
; RUN: llvm-nm -o - < %t2.bc.thinlto.o | FileCheck %s --check-prefix=ALL2 ; RUN: llvm-nm -o - < %t2.bc.thinlto.o | FileCheck %s --check-prefix=ALL2
; ALL: T _callfuncptr ; ALL: T _callfuncptr
; ALL2: T _main ; ALL2: T _main
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
@globalvar_in_section = global i32 1, align 4 @globalvar_in_section = global i32 1, align 4
@globalvar = global i32 1, align 4 @globalvar = global i32 1, align 4
@staticvar = internal global i32 1, align 4 @staticvar = internal global i32 1, align 4
@staticvar2 = internal global i32 1, align 4 @staticvar2 = internal global i32 1, align 4
@staticconstvar = internal unnamed_addr constant [2 x i32] [i32 10, i32 20], align 4 @staticconstvar = internal unnamed_addr constant [2 x i32] [i32 10, i32 20], align 4
@commonvar = common global i32 0, align 4 @commonvar = common global i32 0, align 4
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

llvm/test/ThinLTO/X86/funcimport2.ll

Show All 27 Lines
; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t.o -save-temps \ ; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t.o -save-temps \
; RUN: -O0 \ ; RUN: -O0 \
; RUN: -r=%t1.bc,_foo,plx \ ; RUN: -r=%t1.bc,_foo,plx \
; RUN: -r=%t2.bc,_main,plx \ ; RUN: -r=%t2.bc,_main,plx \
; RUN: -r=%t2.bc,_foo,l ; RUN: -r=%t2.bc,_foo,l
; RUN: llvm-dis %t.o.2.3.import.bc -o - | FileCheck %s --check-prefix=NOIMPORT ; RUN: llvm-dis %t.o.2.3.import.bc -o - | FileCheck %s --check-prefix=NOIMPORT
; NOIMPORT: declare dso_local void @foo(...) ; NOIMPORT: declare dso_local void @foo(...)
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define void @foo() #0 { define void @foo() #0 {
entry: entry:
ret void ret void
} }

llvm/test/ThinLTO/X86/function_entry_count.ll

Show All 15 Lines
; CHECK: define void @h() !prof ![[PROF2:[0-9]+]] ; CHECK: define void @h() !prof ![[PROF2:[0-9]+]]
; CHECK: define void @f(i32{{.*}}) !prof ![[PROF1:[0-9]+]] ; CHECK: define void @f(i32{{.*}}) !prof ![[PROF1:[0-9]+]]
; CHECK: define available_externally void @g() !prof ![[PROF2]] ; CHECK: define available_externally void @g() !prof ![[PROF2]]
; CHECK-DAG: ![[PROF1]] = !{!"synthetic_function_entry_count", i64 10} ; CHECK-DAG: ![[PROF1]] = !{!"synthetic_function_entry_count", i64 10}
; CHECK-DAG: ![[PROF2]] = !{!"synthetic_function_entry_count", i64 198} ; CHECK-DAG: ![[PROF2]] = !{!"synthetic_function_entry_count", i64 198}
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
declare void @g(); declare void @g();
define void @h() { define void @h() {
ret void ret void
} }
define void @f(i32 %n) { define void @f(i32 %n) {
Show All 12 Lines

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

; RUN: opt -module-summary %s -o %t1.bc ; RUN: opt -module-summary %s -o %t1.bc
; RUN: opt -module-summary %p/Inputs/globals-import-blockaddr.ll -o %t2.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,main,pl %t2.bc -r=%t2.bc,foo,pl -o %t3 ; RUN: llvm-lto2 run -save-temps %t1.bc -r=%t1.bc,foo,l -r=%t1.bc,main,pl %t2.bc -r=%t2.bc,foo,pl -o %t3
; RUN: llvm-dis %t3.1.3.import.bc -o - | FileCheck %s ; RUN: llvm-dis %t3.1.3.import.bc -o - | FileCheck %s
; Verify that we haven't imported GV containing blockaddress ; Verify that we haven't imported GV containing blockaddress
; CHECK: @label_addr.llvm.0 = external hidden constant ; CHECK: @label_addr.llvm.0 = external hidden constant
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare dso_local [1 x i8*]* @foo(); declare dso_local [1 x i8*]* @foo();
define dso_local i32 @main() { define dso_local i32 @main() {
%p = call [1 x i8*]* @foo() %p = call [1 x i8*]* @foo()
%v = ptrtoint [1 x i8*]* %p to i32 %v = ptrtoint [1 x i8*]* %p to i32
ret i32 %v ret i32 %v
} }

llvm/test/ThinLTO/X86/globals-import-const-fold.ll

; RUN: opt -module-summary %s -o %t1.bc ; RUN: opt -module-summary %s -o %t1.bc
; RUN: opt -module-summary %p/Inputs/globals-import-cf-baz.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/globals-import-cf-baz.ll -o %t2.bc
; RUN: llvm-lto -thinlto-action=thinlink %t1.bc %t2.bc -o %t3.index.bc ; RUN: llvm-lto -thinlto-action=thinlink %t1.bc %t2.bc -o %t3.index.bc
; RUN: llvm-lto -thinlto-action=import -exported-symbol=main %t1.bc -thinlto-index=%t3.index.bc ; RUN: llvm-lto -thinlto-action=import -exported-symbol=main %t1.bc -thinlto-index=%t3.index.bc
; RUN: llvm-dis %t1.bc.thinlto.imported.bc -o - | FileCheck --check-prefix=IMPORT %s ; RUN: llvm-dis %t1.bc.thinlto.imported.bc -o - | FileCheck --check-prefix=IMPORT %s
; RUN: llvm-lto -thinlto-action=optimize %t1.bc.thinlto.imported.bc -o %t1.bc.thinlto.opt.bc ; RUN: llvm-lto -thinlto-action=optimize %t1.bc.thinlto.imported.bc -o %t1.bc.thinlto.opt.bc
; RUN: llvm-dis %t1.bc.thinlto.opt.bc -o - | FileCheck --check-prefix=OPTIMIZE %s ; RUN: llvm-dis %t1.bc.thinlto.opt.bc -o - | FileCheck --check-prefix=OPTIMIZE %s
; IMPORT: @baz = internal local_unnamed_addr constant i32 10 ; IMPORT: @baz = internal local_unnamed_addr constant i32 10
; OPTIMIZE: define i32 @main() ; OPTIMIZE: define i32 @main()
; OPTIMIZE-NEXT: ret i32 10 ; OPTIMIZE-NEXT: ret i32 10
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
@baz = external local_unnamed_addr constant i32, align 4 @baz = external local_unnamed_addr constant i32, align 4
define i32 @main() local_unnamed_addr { define i32 @main() local_unnamed_addr {
%1 = load i32, i32* @baz, align 4 %1 = load i32, i32* @baz, align 4
ret i32 %1 ret i32 %1
} }

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

Show All 18 Lines
; PROMOTE1: @baz.llvm.0 = hidden constant i32 10, align 4 ; PROMOTE1: @baz.llvm.0 = hidden constant i32 10, align 4
; PROMOTE1: define weak_odr i32 @foo() { ; PROMOTE1: define weak_odr i32 @foo() {
; Second copy of IR object should not have any symbols imported/promoted. ; Second copy of IR object should not have any symbols imported/promoted.
; PROMOTE2: @baz = internal constant i32 10, align 4 ; PROMOTE2: @baz = internal constant i32 10, align 4
; PROMOTE2: define available_externally i32 @foo() { ; PROMOTE2: define available_externally i32 @foo() {
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
declare i32 @foo() declare i32 @foo()
define i32 @main() local_unnamed_addr { define i32 @main() local_unnamed_addr {
%1 = call i32 @foo() %1 = call i32 @foo()
ret i32 %1 ret i32 %1
} }

llvm/test/ThinLTO/X86/import_opaque_type.ll

; Do setup work for all below tests: generate bitcode and combined index ; Do setup work for all below tests: generate bitcode and combined index
; RUN: opt -module-summary %s -o %t.bc ; RUN: opt -module-summary %s -o %t.bc
; RUN: opt -module-summary %p/Inputs/import_opaque_type.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/import_opaque_type.ll -o %t2.bc
; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc ; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc
; Check that we import correctly the imported type to replace the opaque one here ; Check that we import correctly the imported type to replace the opaque one here
; RUN: llvm-lto -thinlto-action=import %t.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s ; RUN: llvm-lto -thinlto-action=import %t.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
; CHECK: %0 = type { i8 } ; CHECK: %0 = type { i8 }
%0 = type opaque %0 = type opaque
%a = type { %0 * } %a = type { %0 * }
declare void @baz() declare void @baz()
Show All 9 Lines

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

; RUN: opt -module-summary %s -o %t1.bc ; RUN: opt -module-summary %s -o %t1.bc
; RUN: opt -module-summary %p/Inputs/index-const-prop-define-g.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/index-const-prop-define-g.ll -o %t2.bc
; RUN: llvm-lto2 run -O0 -save-temps %t2.bc -r=%t2.bc,g,pl %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,g, -o %t3 ; RUN: llvm-lto2 run -O0 -save-temps %t2.bc -r=%t2.bc,g,pl %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,g, -o %t3
; RUN: llvm-dis %t3.1.3.import.bc -o - | FileCheck %s ; RUN: llvm-dis %t3.1.3.import.bc -o - | FileCheck %s
; With -O0 import is disabled so we must not internalize ; With -O0 import is disabled so we must not internalize
; read-only globals ; read-only globals
; CHECK: @g = dso_local global i32 42 ; CHECK: @g = dso_local global i32 42
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@g = external global i32 @g = external global i32
define i32 @main() { define i32 @main() {
%v = load i32, i32* @g %v = load i32, i32* @g
ret i32 %v ret i32 %v
} }

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

Show All 20 Lines
; IMPORT: attributes #0 = { "thinlto-internalize" } ; IMPORT: attributes #0 = { "thinlto-internalize" }
; CODEGEN: define dso_local i32 @main ; CODEGEN: define dso_local i32 @main
; CODEGEN-NEXT: ret i32 42 ; CODEGEN-NEXT: ret i32 42
; PRESERVED: @g.alias = external dso_local global i32 ; PRESERVED: @g.alias = external dso_local global i32
; PRESERVED-NEXT: @g = available_externally dso_local global i32 42, align 4 ; PRESERVED-NEXT: @g = available_externally dso_local global i32 42, align 4
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@g.alias = external global i32 @g.alias = external global i32
@g = external global i32 @g = external global i32
define i32 @main() { define i32 @main() {
%v = load i32, i32* @g %v = load i32, i32* @g
ret i32 %v ret i32 %v
} }
define i32* @ret_ptr() { define i32* @ret_ptr() {
ret i32* @g.alias ret i32* @g.alias
} }

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

Show All 23 Lines
; RUN: ls %t.cache/llvmcache-* | count 3 ; RUN: ls %t.cache/llvmcache-* | count 3
; RUN: llvm-lto2 run %t1.bc %t3.bc %t2.bc -cache-dir %t.cache -o %t6 \ ; RUN: llvm-lto2 run %t1.bc %t3.bc %t2.bc -cache-dir %t.cache -o %t6 \
; RUN: -r=%t1.bc,main,plx -r=%t1.bc,foo,l \ ; RUN: -r=%t1.bc,main,plx -r=%t1.bc,foo,l \
; RUN: -r=%t3.bc,test,plx -r=%t3.bc,foo,l \ ; RUN: -r=%t3.bc,test,plx -r=%t3.bc,foo,l \
; RUN: -r=%t2.bc,foo,pl -r=%t2.bc,bar,pl -r=%t2.bc,rand, ; RUN: -r=%t2.bc,foo,pl -r=%t2.bc,bar,pl -r=%t2.bc,rand,
; RUN: ls %t.cache/llvmcache-* | count 6 ; RUN: ls %t.cache/llvmcache-* | count 6
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define i32 @main() local_unnamed_addr { define i32 @main() local_unnamed_addr {
%1 = tail call i32 (...) @foo() %1 = tail call i32 (...) @foo()
ret i32 %1 ret i32 %1
} }
declare i32 @foo(...) local_unnamed_addr declare i32 @foo(...) local_unnamed_addr

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

; RUN: opt -module-summary %s -o %t1.bc ; RUN: opt -module-summary %s -o %t1.bc
; RUN: opt -module-summary %p/Inputs/index-const-prop-comdat.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/index-const-prop-comdat.ll -o %t2.bc
; RUN: llvm-lto2 run -save-temps %t2.bc -r=%t2.bc,g,pl %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,g, -o %t3 ; RUN: llvm-lto2 run -save-temps %t2.bc -r=%t2.bc,g,pl %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,g, -o %t3
; RUN: llvm-dis %t3.2.3.import.bc -o - | FileCheck %s ; RUN: llvm-dis %t3.2.3.import.bc -o - | FileCheck %s
; Comdats are not internalized even if they are read only. ; Comdats are not internalized even if they are read only.
; CHECK: @g = available_externally dso_local global i32 42 ; CHECK: @g = available_externally dso_local global i32 42
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@g = external global i32 @g = external global i32
define i32 @main() { define i32 @main() {
%v = load i32, i32* @g %v = load i32, i32* @g
ret i32 %v ret i32 %v
} }

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

; RUN: opt -module-summary %s -o %t1.bc ; RUN: opt -module-summary %s -o %t1.bc
; RUN: opt -module-summary %p/Inputs/index-const-prop-define-g.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/index-const-prop-define-g.ll -o %t2.bc
; RUN: llvm-lto2 run -save-temps %t2.bc -r=%t2.bc,g,pl \ ; RUN: llvm-lto2 run -save-temps %t2.bc -r=%t2.bc,g,pl \
; RUN: %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,foo,pl -r=%t1.bc,g, -o %t3 ; RUN: %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,foo,pl -r=%t1.bc,g, -o %t3
; RUN: llvm-dis %t3.2.3.import.bc -o - | FileCheck %s ; RUN: llvm-dis %t3.2.3.import.bc -o - | FileCheck %s
; Dead globals are converted to declarations by ThinLTO in dropDeadSymbols ; Dead globals are converted to declarations by ThinLTO in dropDeadSymbols
; If we try to internalize such we'll get a broken module. ; If we try to internalize such we'll get a broken module.
; CHECK: @g = external dso_local global i32 ; CHECK: @g = external dso_local global i32
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@g = external global i32 @g = external global i32
; We need at least one live symbol to enable dead stripping ; We need at least one live symbol to enable dead stripping
; Otherwise ModuleSummaryIndex::isGlobalValueLive will always ; Otherwise ModuleSummaryIndex::isGlobalValueLive will always
; return true. ; return true.
define i32 @main() { define i32 @main() {
ret i32 42 ret i32 42
} }
define i32 @foo() { define i32 @foo() {
%v = load i32, i32* @g %v = load i32, i32* @g
ret i32 %v ret i32 %v
} }

llvm/test/ThinLTO/X86/index-const-prop-full-lto.ll

; RUN: opt -module-summary %s -o %t1.bc ; RUN: opt -module-summary %s -o %t1.bc
; RUN: opt -module-summary %p/Inputs/index-const-prop-define-g.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/index-const-prop-define-g.ll -o %t2.bc
; RUN: opt -module-summary %p/Inputs/index-const-prop-full-lto.ll -o %t3.bc ; RUN: opt -module-summary %p/Inputs/index-const-prop-full-lto.ll -o %t3.bc
; RUN: llvm-lto2 run -save-temps %t2.bc -r=%t2.bc,g,pl \ ; RUN: llvm-lto2 run -save-temps %t2.bc -r=%t2.bc,g,pl \
; RUN: %t1.bc -r=%t1.bc,foo,l -r=%t1.bc,main,plx -r=%t1.bc,g, \ ; RUN: %t1.bc -r=%t1.bc,foo,l -r=%t1.bc,main,plx -r=%t1.bc,g, \
; RUN: %t3.bc -r=%t3.bc,foo,pl -r=%t3.bc,g, -o %t4 ; RUN: %t3.bc -r=%t3.bc,foo,pl -r=%t3.bc,g, -o %t4
; RUN: llvm-dis %t4.2.3.import.bc -o - | FileCheck %s ; RUN: llvm-dis %t4.2.3.import.bc -o - | FileCheck %s
; All references from functions in full LTO module are not constant. ; All references from functions in full LTO module are not constant.
; We cannot internalize @g ; We cannot internalize @g
; CHECK: @g = available_externally dso_local global i32 42 ; CHECK: @g = available_externally dso_local global i32 42
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare i32 @foo() declare i32 @foo()
@g = external global i32 @g = external global i32
define i32 @main() { define i32 @main() {
%v = call i32 @foo() %v = call i32 @foo()
%v2 = load i32, i32* @g %v2 = load i32, i32* @g
%v3 = add i32 %v, %v2 %v3 = add i32 %v, %v2
ret i32 %v3 ret i32 %v3
} }

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

; RUN: opt -module-summary %s -o %t1.bc ; RUN: opt -module-summary %s -o %t1.bc
; RUN: opt -module-summary %p/Inputs/index-const-prop-gvref.ll -o %t2.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: 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: %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.1.3.import.bc -o - | FileCheck %s --check-prefix=SRC
; RUN: llvm-dis %t3.2.3.import.bc -o - | FileCheck %s --check-prefix=DEST ; RUN: llvm-dis %t3.2.3.import.bc -o - | FileCheck %s --check-prefix=DEST
; No variable in the source module should have been internalized ; No variable in the source module should have been internalized
; SRC: @b = dso_local global i32* @a ; SRC: @b = dso_local global i32* @a
; SRC-NEXT: @a = dso_local global i32 42 ; SRC-NEXT: @a = dso_local global i32 42
; We can't internalize globals referenced by other live globals ; We can't internalize globals referenced by other live globals
; DEST: @b = external dso_local global i32* ; DEST: @b = external dso_local global i32*
; DEST-NEXT: @a = available_externally dso_local global i32 42, align 4 ; DEST-NEXT: @a = available_externally dso_local global i32 42, align 4
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@a = external global i32 @a = external global i32
@b = external global i32* @b = external global i32*
define i32 @main() { define i32 @main() {
%p = load i32*, i32** @b, align 8 %p = load i32*, i32** @b, align 8
store i32 33, i32* %p, align 4 store i32 33, i32* %p, align 4
%v = load i32, i32* @a, align 4 %v = load i32, i32* @a, align 4
ret i32 %v ret i32 %v
} }

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

; RUN: opt -module-summary %s -o %t1.bc ; RUN: opt -module-summary %s -o %t1.bc
; RUN: opt -module-summary %p/Inputs/index-const-prop-define-g.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/index-const-prop-define-g.ll -o %t2.bc
; RUN: llvm-lto2 run -save-temps %t2.bc -r=%t2.bc,g,pl %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,g, -o %t3 ; RUN: llvm-lto2 run -save-temps %t2.bc -r=%t2.bc,g,pl %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,g, -o %t3
; RUN: llvm-dis %t3.2.3.import.bc -o - | FileCheck %s ; RUN: llvm-dis %t3.2.3.import.bc -o - | FileCheck %s
; The 'store' instruction in @main should prevent internalization ; The 'store' instruction in @main should prevent internalization
; even when there is 'load' instruction before it. ; even when there is 'load' instruction before it.
; CHECK: @g = available_externally dso_local global i32 42 ; CHECK: @g = available_externally dso_local global i32 42
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@g = external global i32 @g = external global i32
define i32 @main() { define i32 @main() {
%v = load i32, i32* @g %v = load i32, i32* @g
%q = add i32 %v, 1 %q = add i32 %v, 1
store i32 %q, i32* @g store i32 %q, i32* @g
ret i32 %v ret i32 %v
} }

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

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

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

Show All 22 Lines
; IMPORT-NEXT: @gBar = internal local_unnamed_addr global i32 2, align 4, !dbg !5 ; IMPORT-NEXT: @gBar = internal local_unnamed_addr global i32 2, align 4, !dbg !5
; IMPORT: !DICompileUnit({{.*}}) ; IMPORT: !DICompileUnit({{.*}})
; OPTIMIZE: define i32 @main ; OPTIMIZE: define i32 @main
; OPTIMIZE-NEXT: ret i32 3 ; OPTIMIZE-NEXT: ret i32 3
; IMPORT2: @gBar = available_externally local_unnamed_addr global i32 2, align 4, !dbg !5 ; IMPORT2: @gBar = available_externally local_unnamed_addr global i32 2, align 4, !dbg !5
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
@gBar = external global i32 @gBar = external global i32
; Should not be counted in the stats of live read only variables since it is ; Should not be counted in the stats of live read only variables since it is
; dead and will be dropped anyway. ; dead and will be dropped anyway.
@gDead = internal unnamed_addr global i32 1, align 4 @gDead = internal unnamed_addr global i32 1, align 4
Show All 10 Lines

llvm/test/ThinLTO/X86/index-const-prop2.ll

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
; CODEGEN2-NEXT: %2 = tail call i32 @rand() ; CODEGEN2-NEXT: %2 = tail call i32 @rand()
; CODEGEN2-NEXT: ret i32 0 ; CODEGEN2-NEXT: ret i32 0
; CODEGEN2-SRC: void @baz() ; CODEGEN2-SRC: void @baz()
; CODEGEN2-SRC-NEXT: %1 = tail call i32 @rand() ; CODEGEN2-SRC-NEXT: %1 = tail call i32 @rand()
; CODEGEN2-SRC-NEXT: %2 = tail call i32 @rand() ; CODEGEN2-SRC-NEXT: %2 = tail call i32 @rand()
; CODEGEN2-SRC-NEXT: ret void ; CODEGEN2-SRC-NEXT: ret void
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; We should be able to link external definition of gBar to its declaration ; We should be able to link external definition of gBar to its declaration
@gBar = external global i32 @gBar = external global i32
define i32 @main() local_unnamed_addr { define i32 @main() local_unnamed_addr {
%call = tail call i32 bitcast (i32 (...)* @foo to i32 ()*)() %call = tail call i32 bitcast (i32 (...)* @foo to i32 ()*)()
%call1 = tail call i32 bitcast (i32 (...)* @bar to i32 ()*)() %call1 = tail call i32 bitcast (i32 (...)* @bar to i32 ()*)()
Show All 14 Lines

llvm/test/ThinLTO/X86/internalize.ll

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
; INTERNALIZE2: define internal void @weak_func_prevailing() ; INTERNALIZE2: define internal void @weak_func_prevailing()
; INTERNALIZE2: define weak dso_local void @weak_func_nonprevailing() ; INTERNALIZE2: define weak dso_local void @weak_func_nonprevailing()
; INTERNALIZE2-OPTION-DISABLE: define dso_local void @foo ; INTERNALIZE2-OPTION-DISABLE: define dso_local void @foo
; INTERNALIZE2-OPTION-DISABLE: define dso_local void @bar ; INTERNALIZE2-OPTION-DISABLE: define dso_local void @bar
; INTERNALIZE2-OPTION-DISABLE: define weak dso_local void @linkonce_func() ; INTERNALIZE2-OPTION-DISABLE: define weak dso_local void @linkonce_func()
; INTERNALIZE2-OPTION-DISABLE: define weak dso_local void @weak_func_prevailing() ; INTERNALIZE2-OPTION-DISABLE: define weak dso_local void @weak_func_prevailing()
; INTERNALIZE2-OPTION-DISABLE: define weak dso_local void @weak_func_nonprevailing() ; INTERNALIZE2-OPTION-DISABLE: define weak dso_local void @weak_func_nonprevailing()
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define void @foo() { define void @foo() {
call void @bar() call void @bar()
ret void ret void
} }
define void @bar() { define void @bar() {
call void @linkonce_func() call void @linkonce_func()
Show All 17 Lines

llvm/test/ThinLTO/X86/lazyload_metadata.ll

Show All 14 Lines
; RUN: llvm-lto -thinlto-action=import %t2.bc -thinlto-index=%t3.bc \ ; RUN: llvm-lto -thinlto-action=import %t2.bc -thinlto-index=%t3.bc \
; RUN: -o /dev/null -disable-ondemand-mds-loading -stats \ ; RUN: -o /dev/null -disable-ondemand-mds-loading -stats \
; RUN: 2>&1 | FileCheck %s -check-prefix=NOTLAZY ; RUN: 2>&1 | FileCheck %s -check-prefix=NOTLAZY
; NOTLAZY: 70 bitcode-reader - Number of Metadata records loaded ; NOTLAZY: 70 bitcode-reader - Number of Metadata records loaded
; NOTLAZY: 7 bitcode-reader - Number of MDStrings loaded ; NOTLAZY: 7 bitcode-reader - Number of MDStrings loaded
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define void @globalfunc1(i32 %arg) { define void @globalfunc1(i32 %arg) {
%x = call i1 @llvm.type.test(i8* undef, metadata !"typeid1") %x = call i1 @llvm.type.test(i8* undef, metadata !"typeid1")
%tmp = add i32 %arg, 0, !metadata !2 %tmp = add i32 %arg, 0, !metadata !2
ret void ret void
} }
Show All 27 Lines

llvm/test/ThinLTO/X86/linkonce_aliasee_ref_import.ll

Show All 18 Lines
; RUN: llvm-nm -o - < %t2.bc.thinlto.o | FileCheck %s --check-prefix=NM2 ; RUN: llvm-nm -o - < %t2.bc.thinlto.o | FileCheck %s --check-prefix=NM2
; Check that we converted baz.clone to a weak ; Check that we converted baz.clone to a weak
; NM1: W baz.clone ; NM1: W baz.clone
; Check that we imported a ref (and not def) to baz.clone ; Check that we imported a ref (and not def) to baz.clone
; NM2: U baz.clone ; NM2: U baz.clone
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
$baz.clone = comdat any $baz.clone = comdat any
@baz = weak alias void (), void ()* @baz.clone @baz = weak alias void (), void ()* @baz.clone
define void @foo() #5 align 2 { define void @foo() #5 align 2 {
tail call void @baz.clone() tail call void @baz.clone()
ret void ret void
Show All 15 Lines

llvm/test/ThinLTO/X86/linkonce_odr_unnamed_addr.ll

Show All 11 Lines
; Now test when one module does not have a summary. In that case we must be ; Now test when one module does not have a summary. In that case we must be
; conservative and not auto hide. ; conservative and not auto hide.
; RUN: opt %p/Inputs/linkonce_odr_unnamed_addr.ll -o %t4.bc ; RUN: opt %p/Inputs/linkonce_odr_unnamed_addr.ll -o %t4.bc
; Check new LTO API (old LTO API does not detect this case). ; Check new LTO API (old LTO API does not detect this case).
; RUN: llvm-lto2 run -save-temps -o %t6.bc %t.bc %t4.bc -r=%t.bc,linkonceodrunnamed,p -r=%t.bc,odrunnamed,p -r=%t4.bc,linkonceodrunnamed, -r=%t4.bc,odrunnamed, ; RUN: llvm-lto2 run -save-temps -o %t6.bc %t.bc %t4.bc -r=%t.bc,linkonceodrunnamed,p -r=%t.bc,odrunnamed,p -r=%t4.bc,linkonceodrunnamed, -r=%t4.bc,odrunnamed,
; RUN: llvm-dis %t6.bc.1.1.promote.bc -o - | FileCheck %s --check-prefix=NOSUMMARY ; RUN: llvm-dis %t6.bc.1.1.promote.bc -o - | FileCheck %s --check-prefix=NOSUMMARY
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
; In this case all copies are linkonce_odr, so it may be hidden. ; In this case all copies are linkonce_odr, so it may be hidden.
; CHECK: @linkonceodrunnamed = weak_odr hidden unnamed_addr constant i32 0 ; CHECK: @linkonceodrunnamed = weak_odr hidden unnamed_addr constant i32 0
; NOSUMMARY: @linkonceodrunnamed = weak_odr unnamed_addr constant i32 0 ; NOSUMMARY: @linkonceodrunnamed = weak_odr unnamed_addr constant i32 0
@linkonceodrunnamed = linkonce_odr unnamed_addr constant i32 0 @linkonceodrunnamed = linkonce_odr unnamed_addr constant i32 0
; In this case, the other copy was weak_odr, so it may not be hidden. ; In this case, the other copy was weak_odr, so it may not be hidden.
; CHECK: @odrunnamed = weak_odr unnamed_addr constant i32 0 ; CHECK: @odrunnamed = weak_odr unnamed_addr constant i32 0
; NOSUMMARY: @odrunnamed = weak_odr unnamed_addr constant i32 0 ; NOSUMMARY: @odrunnamed = weak_odr unnamed_addr constant i32 0
@odrunnamed = linkonce_odr unnamed_addr constant i32 0 @odrunnamed = linkonce_odr unnamed_addr constant i32 0

llvm/test/ThinLTO/X86/linkonce_resolution_comdat.ll

Show All 15 Lines
; RUN: llvm-nm -o - < %t1.bc.thinlto.o | FileCheck %s --check-prefix=NM1 ; RUN: llvm-nm -o - < %t1.bc.thinlto.o | FileCheck %s --check-prefix=NM1
; NM1: W f ; NM1: W f
; RUN: llvm-nm -o - < %t2.bc.thinlto.o | FileCheck %s --check-prefix=NM2 ; RUN: llvm-nm -o - < %t2.bc.thinlto.o | FileCheck %s --check-prefix=NM2
; f() would have been turned into available_externally since it is preempted, ; f() would have been turned into available_externally since it is preempted,
; and inlined into g() ; and inlined into g()
; NM2-NOT: f ; NM2-NOT: f
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
$c1 = comdat any $c1 = comdat any
define linkonce_odr i32 @f(i8*) unnamed_addr comdat($c1) { define linkonce_odr i32 @f(i8*) unnamed_addr comdat($c1) {
ret i32 43 ret i32 43
} }

llvm/test/ThinLTO/X86/llvm.used.ll

; Do setup work for all below tests: generate bitcode and combined index ; Do setup work for all below tests: generate bitcode and combined index
; RUN: opt -module-summary %s -o %t.bc ; RUN: opt -module-summary %s -o %t.bc
; RUN: opt -module-summary %p/Inputs/llvm.used.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/llvm.used.ll -o %t2.bc
; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc ; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc
; RUN: llvm-lto -thinlto-action=import %t2.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s ; RUN: llvm-lto -thinlto-action=import %t2.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s
; CHECK: define available_externally void @globalfunc ; CHECK: define available_externally void @globalfunc
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define internal void @_ZN12_GLOBAL__N_16Module4dumpEv() { define internal void @_ZN12_GLOBAL__N_16Module4dumpEv() {
ret void ret void
} }
@llvm.used = appending global [1 x i8*] [i8* bitcast (void ()* @_ZN12_GLOBAL__N_16Module4dumpEv to i8*)], section "llvm.metadata" @llvm.used = appending global [1 x i8*] [i8* bitcast (void ()* @_ZN12_GLOBAL__N_16Module4dumpEv to i8*)], section "llvm.metadata"
define void @globalfunc() #0 { define void @globalfunc() #0 {
entry: entry:
ret void ret void
} }

llvm/test/ThinLTO/X86/load-store-caching.ll

; Test that instruction operands from loads are not cached when ; Test that instruction operands from loads are not cached when
; processing stores. Reference from @foo to @obj should not be ; processing stores. Reference from @foo to @obj should not be
; readonly or writeonly ; readonly or writeonly
; RUN: opt -module-summary %s -o %t.bc ; RUN: opt -module-summary %s -o %t.bc
; RUN: llvm-dis %t.bc -o - | FileCheck %s ; RUN: llvm-dis %t.bc -o - | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
%struct.S = type { %struct.Derived* } %struct.S = type { %struct.Derived* }
%struct.Derived = type { i32 } %struct.Derived = type { i32 }
%struct.Base = type { i32 } %struct.Base = type { i32 }
@obj = dso_local local_unnamed_addr global %struct.S zeroinitializer, align 8 @obj = dso_local local_unnamed_addr global %struct.S zeroinitializer, align 8
Show All 10 Lines

llvm/test/ThinLTO/X86/local_name_conflict.ll

Show All 22 Lines
; Make sure foo is promoted and renamed without complaint in %t3.bc. ; Make sure foo is promoted and renamed without complaint in %t3.bc.
; RUN: llvm-lto -thinlto-action=promote %t3.bc -thinlto-index=%t4.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=EXPORTSTATIC ; RUN: llvm-lto -thinlto-action=promote %t3.bc -thinlto-index=%t4.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=EXPORTSTATIC
; EXPORTSTATIC: @baz.llvm.{{.*}} = hidden constant i32 10, align 4 ; EXPORTSTATIC: @baz.llvm.{{.*}} = hidden constant i32 10, align 4
; EXPORTSTATIC: define hidden i32 @foo.llvm. ; EXPORTSTATIC: define hidden i32 @foo.llvm.
; ModuleID = 'local_name_conflict_main.o' ; ModuleID = 'local_name_conflict_main.o'
source_filename = "local_name_conflict_main.c" source_filename = "local_name_conflict_main.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: noinline nounwind uwtable ; Function Attrs: noinline nounwind uwtable
define i32 @main() { define i32 @main() {
entry: entry:
%retval = alloca i32, align 4 %retval = alloca i32, align 4
store i32 0, i32* %retval, align 4 store i32 0, i32* %retval, align 4
%call = call i32 (...) @b() %call = call i32 (...) @b()
ret i32 %call ret i32 %call
} }
declare i32 @b(...) declare i32 @b(...)

llvm/test/ThinLTO/X86/local_name_conflict_var.ll

Show All 11 Lines
; of baz from each of those modules to be imported. Check that the both are ; of baz from each of those modules to be imported. Check that the both are
; imported as local copies. ; imported as local copies.
; RUN: llvm-lto -thinlto-action=import -exported-symbol=main %t.bc -thinlto-index=%t4.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=IMPORT ; RUN: llvm-lto -thinlto-action=import -exported-symbol=main %t.bc -thinlto-index=%t4.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=IMPORT
; IMPORT: @baz.llvm.{{.*}} = internal global i32 10 ; IMPORT: @baz.llvm.{{.*}} = internal global i32 10
; IMPORT: @baz.llvm.{{.*}} = internal global i32 10 ; IMPORT: @baz.llvm.{{.*}} = internal global i32 10
; ModuleID = 'local_name_conflict_var_main.o' ; ModuleID = 'local_name_conflict_var_main.o'
source_filename = "local_name_conflict_var_main.c" source_filename = "local_name_conflict_var_main.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: noinline nounwind uwtable ; Function Attrs: noinline nounwind uwtable
define i32 @main() { define i32 @main() {
entry: entry:
%call1 = call i32 (...) @a() %call1 = call i32 (...) @a()
%call2 = call i32 (...) @b() %call2 = call i32 (...) @b()
ret i32 0 ret i32 0
} }
declare i32 @a(...) declare i32 @a(...)
declare i32 @b(...) declare i32 @b(...)

llvm/test/ThinLTO/X86/merge-triple.ll

; RUN: opt -module-summary %s -o %t1.bc ; RUN: opt -module-summary %s -o %t1.bc
; RUN: opt -module-summary %p/Inputs/merge-triple.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/merge-triple.ll -o %t2.bc
; RUN: llvm-lto -thinlto-action=optimize %t1.bc %t2.bc ; RUN: llvm-lto -thinlto-action=optimize %t1.bc %t2.bc
; RUN: llvm-dis < %t1.bc.thinlto.imported.bc | FileCheck %s --check-prefix=CHECK1 ; RUN: llvm-dis < %t1.bc.thinlto.imported.bc | FileCheck %s --check-prefix=CHECK1
; RUN: llvm-dis < %t2.bc.thinlto.imported.bc | FileCheck %s --check-prefix=CHECK2 ; RUN: llvm-dis < %t2.bc.thinlto.imported.bc | FileCheck %s --check-prefix=CHECK2
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.12.0" target triple = "x86_64-apple-macosx10.12.0"
; CHECK1: target triple = "x86_64-apple-macosx10.12.0" ; CHECK1: target triple = "x86_64-apple-macosx10.12.0"
; CHECK2: target triple = "x86_64-apple-macosx10.11.0" ; CHECK2: target triple = "x86_64-apple-macosx10.11.0"

llvm/test/ThinLTO/X86/module_asm2.ll

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
; NM1-DAG: U func3 ; NM1-DAG: U func3
; NM1-DAG: U globalfunc ; NM1-DAG: U globalfunc
; NM1-DAG: U weakfunc ; NM1-DAG: U weakfunc
; NM1-DAG: T main ; NM1-DAG: T main
; NM1-NOT: foo ; NM1-NOT: foo
; NM1-NOT: b ; NM1-NOT: b
; NM1-NOT: x ; NM1-NOT: x
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@b = internal global i32 1, align 4 @b = internal global i32 1, align 4
@x = internal global i32 1, align 4 @x = internal global i32 1, align 4
@llvm.compiler.used = appending global [1 x i8*] [i8* bitcast (i32* @b to i8*)], section "llvm.metadata" @llvm.compiler.used = appending global [1 x i8*] [i8* bitcast (i32* @b to i8*)], section "llvm.metadata"
@llvm.used = appending global [1 x i8*] [i8* bitcast (i32* @x to i8*)], section "llvm.metadata" @llvm.used = appending global [1 x i8*] [i8* bitcast (i32* @x to i8*)], section "llvm.metadata"
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

llvm/test/ThinLTO/X86/module_asm_glob.ll

Show All 11 Lines
; RUN: -r=%t2.bc,main,plx \ ; RUN: -r=%t2.bc,main,plx \
; RUN: -r=%t2.bc,_simplefunction,l ; RUN: -r=%t2.bc,_simplefunction,l
; RUN: llvm-nm %t.o.1 | FileCheck %s --check-prefix=NM0 ; RUN: llvm-nm %t.o.1 | FileCheck %s --check-prefix=NM0
; RUN: llvm-nm %t.o.2 | FileCheck %s --check-prefix=NM1 ; RUN: llvm-nm %t.o.2 | FileCheck %s --check-prefix=NM1
; NM0: T foo ; NM0: T foo
; NM1-NOT: foo ; NM1-NOT: foo
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
module asm "\09.text" module asm "\09.text"
module asm "\09.globl\09foo" module asm "\09.globl\09foo"
module asm "\09.align\0916, 0x90" module asm "\09.align\0916, 0x90"
module asm "\09.type\09foo,@function" module asm "\09.type\09foo,@function"
module asm "foo:" module asm "foo:"
module asm "\09ret " module asm "\09ret "
module asm "\09.size\09foo, .-foo" module asm "\09.size\09foo, .-foo"
module asm "" module asm ""
declare zeroext i16 @foo() #0 declare zeroext i16 @foo() #0
define i32 @_simplefunction() #1 { define i32 @_simplefunction() #1 {
ret i32 1 ret i32 1
} }

llvm/test/ThinLTO/X86/module_summary_graph_traits.ll

Show All 25 Lines
; CHECK-NEXT: {{^}} 5800840261926955363{{$}} ; CHECK-NEXT: {{^}} 5800840261926955363{{$}}
; CHECK-NEXT: } ; CHECK-NEXT: }
; Dummy call graph root that points at all roots of the callgraph. ; Dummy call graph root that points at all roots of the callgraph.
; CHECK: SCC (1 node) { ; CHECK: SCC (1 node) {
; CHECK-NEXT: {{^}} 0{{$}} ; CHECK-NEXT: {{^}} 0{{$}}
; CHECK-NEXT: } ; CHECK-NEXT: }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare void @external() declare void @external()
define void @l2() { define void @l2() {
call void @l1() call void @l1()
ret void ret void
} }
Show All 16 Lines

llvm/test/ThinLTO/X86/newpm-basic.ll

; RUN: opt -module-summary %s -o %t1.bc ; RUN: opt -module-summary %s -o %t1.bc
; RUN: llvm-lto2 run %t1.bc -o %t.o \ ; RUN: llvm-lto2 run %t1.bc -o %t.o \
; RUN: -r=%t1.bc,_tinkywinky,pxl \ ; RUN: -r=%t1.bc,_tinkywinky,pxl \
; RUN: -use-new-pm ; RUN: -use-new-pm
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define void @tinkywinky() { define void @tinkywinky() {
ret void ret void
} }

llvm/test/ThinLTO/X86/nodevirt-nonpromoted-typeid.ll

Show All 24 Lines
; New PM, Index based WPD ; New PM, Index based WPD
; RUN: llvm-lto2 run %t2.o -save-temps -use-new-pm -pass-remarks=. \ ; RUN: llvm-lto2 run %t2.o -save-temps -use-new-pm -pass-remarks=. \
; RUN: -o %t3 \ ; RUN: -o %t3 \
; RUN: -r=%t2.o,test,plx \ ; RUN: -r=%t2.o,test,plx \
; RUN: -r=%t2.o,_ZN1D1mEi, ; RUN: -r=%t2.o,_ZN1D1mEi,
; RUN: llvm-dis %t3.1.4.opt.bc -o - | FileCheck %s --check-prefix=CHECK-IR ; RUN: llvm-dis %t3.1.4.opt.bc -o - | FileCheck %s --check-prefix=CHECK-IR
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
%struct.D = type { i32 (...)** } %struct.D = type { i32 (...)** }
@_ZTV1D = internal constant { [3 x i8*] } { [3 x i8*] [i8* null, i8* undef, i8* bitcast (i32 (%struct.D*, i32)* @_ZN1D1mEi to i8*)] }, !type !3 @_ZTV1D = internal constant { [3 x i8*] } { [3 x i8*] [i8* null, i8* undef, i8* bitcast (i32 (%struct.D*, i32)* @_ZN1D1mEi to i8*)] }, !type !3
; CHECK-IR-LABEL: define weak_odr dso_local i32 @test ; CHECK-IR-LABEL: define weak_odr dso_local i32 @test
define weak_odr i32 @test(%struct.D* %obj2, i32 %a) { define weak_odr i32 @test(%struct.D* %obj2, i32 %a) {
Show All 25 Lines

llvm/test/ThinLTO/X86/noinline.ll

; This test checks that ThinLTO doesn't try to import noinline function ; This test checks that ThinLTO doesn't try to import noinline function
; which, when takes place, causes promotion of its callee. ; which, when takes place, causes promotion of its callee.
; RUN: opt -module-summary %s -o %t1.bc ; RUN: opt -module-summary %s -o %t1.bc
; RUN: opt -module-summary %p/Inputs/noinline.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/noinline.ll -o %t2.bc
; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t3.o \ ; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t3.o \
; RUN: -save-temps \ ; RUN: -save-temps \
; RUN: -r=%t1.bc,main,px \ ; RUN: -r=%t1.bc,main,px \
; RUN: -r=%t1.bc,foo, \ ; RUN: -r=%t1.bc,foo, \
; RUN: -r=%t2.bc,foo,p ; RUN: -r=%t2.bc,foo,p
; RUN: llvm-dis %t3.o.1.3.import.bc -o - | FileCheck %s ; RUN: llvm-dis %t3.o.1.3.import.bc -o - | FileCheck %s
; CHECK-NOT: define available_externally i32 @foo ; CHECK-NOT: define available_externally i32 @foo
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define i32 @main(i32, i8** nocapture readnone) local_unnamed_addr #0 { define i32 @main(i32, i8** nocapture readnone) local_unnamed_addr #0 {
%3 = tail call i32 @foo(i32 %0) #0 %3 = tail call i32 @foo(i32 %0) #0
ret i32 %3 ret i32 %3
} }
declare i32 @foo(i32) local_unnamed_addr declare i32 @foo(i32) local_unnamed_addr
attributes #0 = { nounwind } attributes #0 = { nounwind }

llvm/test/ThinLTO/X86/personality-local.ll

Show All 12 Lines
; CHECK-NEXT: Value: 0x0 ; CHECK-NEXT: Value: 0x0
; CHECK-NEXT: Size: 1 ; CHECK-NEXT: Size: 1
; CHECK-NEXT: Binding: Global ; CHECK-NEXT: Binding: Global
; CHECK-NEXT: Type: Function ; CHECK-NEXT: Type: Function
; CHECK-NEXT: Other: 0 ; CHECK-NEXT: Other: 0
; CHECK-NEXT: Section: .text ; CHECK-NEXT: Section: .text
; CHECK-NEXT: } ; CHECK-NEXT: }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
declare void @foo() declare void @foo()
define void @bar() personality i32 (i32, i32, i64, i8*, i8*)* @personality_routine { define void @bar() personality i32 (i32, i32, i64, i8*, i8*)* @personality_routine {
ret void ret void
} }
Show All 10 Lines

llvm/test/ThinLTO/X86/personality.ll

Show All 36 Lines
; BINDING-NEXT: Other [ ; BINDING-NEXT: Other [
; BINDING-NEXT: STV_PROTECTED ; BINDING-NEXT: STV_PROTECTED
; BINDING-NEXT: ] ; BINDING-NEXT: ]
; BINDING-NEXT: Section: .text ; BINDING-NEXT: Section: .text
; BINDING-NEXT: } ; BINDING-NEXT: }
; BINDING-NOT: Name: personality_routine3 ; BINDING-NOT: Name: personality_routine3
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
declare protected i32 @personality_routine(i32, i32, i64, i8*, i8*) declare protected i32 @personality_routine(i32, i32, i64, i8*, i8*)
declare protected i32 @personality_routine2(i32, i32, i64, i8*, i8*) declare protected i32 @personality_routine2(i32, i32, i64, i8*, i8*)
declare protected i32 @personality_routine3(i32, i32, i64, i8*, i8*) declare protected i32 @personality_routine3(i32, i32, i64, i8*, i8*)
declare void @bar() declare void @bar()
define void @foo() personality i32 (i32, i32, i64, i8*, i8*)* @personality_routine { define void @foo() personality i32 (i32, i32, i64, i8*, i8*)* @personality_routine {
Show All 26 Lines

llvm/test/ThinLTO/X86/pr35472.ll

; Test to make sure that lazily loaded debug location scope metadata is ; Test to make sure that lazily loaded debug location scope metadata is
; handled properly. Note that we need to have the DILexicalScope !34 ; handled properly. Note that we need to have the DILexicalScope !34
; referenced from multiple function's debug locs for this to be in the ; referenced from multiple function's debug locs for this to be in the
; lazily loaded module level metadata block. ; lazily loaded module level metadata block.
; RUN: opt -module-hash -module-summary %s -o %t1.bc ; RUN: opt -module-hash -module-summary %s -o %t1.bc
; RUN: opt -module-hash -module-summary %p/Inputs/pr35472.ll -o %t2.bc ; RUN: opt -module-hash -module-summary %p/Inputs/pr35472.ll -o %t2.bc
; RUN: llvm-lto -thinlto-action=run %t1.bc %t2.bc -exported-symbol=_Z5Alphav ; RUN: llvm-lto -thinlto-action=run %t1.bc %t2.bc -exported-symbol=_Z5Alphav
; RUN: llvm-nm %t1.bc.thinlto.o | FileCheck %s -check-prefix=ThinLTOa ; RUN: llvm-nm %t1.bc.thinlto.o | FileCheck %s -check-prefix=ThinLTOa
; RUN: llvm-nm %t2.bc.thinlto.o | FileCheck %s -check-prefix=ThinLTOb ; RUN: llvm-nm %t2.bc.thinlto.o | FileCheck %s -check-prefix=ThinLTOb
; ThinLTOa-DAG: T _Z5Bravov ; ThinLTOa-DAG: T _Z5Bravov
; ThinLTOa-DAG: W _ZN4EchoD2Ev ; ThinLTOa-DAG: W _ZN4EchoD2Ev
; ThinLTOb-DAG: T _Z5Alphav ; ThinLTOb-DAG: T _Z5Alphav
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
%struct.Delta = type { %struct.Charlie } %struct.Delta = type { %struct.Charlie }
%struct.Charlie = type { i32 } %struct.Charlie = type { i32 }
%struct.Echo = type { %struct.Charlie } %struct.Echo = type { %struct.Charlie }
$_ZN4EchoD2Ev = comdat any $_ZN4EchoD2Ev = comdat any
$_ZN5DeltaD2Ev = comdat any $_ZN5DeltaD2Ev = comdat any
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

llvm/test/ThinLTO/X86/reference_non_importable.ll

; RUN: opt -module-summary %s -o %t1.bc ; RUN: opt -module-summary %s -o %t1.bc
; RUN: opt -module-summary %p/Inputs/reference_non_importable.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/reference_non_importable.ll -o %t2.bc
; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t.o -save-temps \ ; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t.o -save-temps \
; RUN: -r=%t1.bc,_foo,pxl \ ; RUN: -r=%t1.bc,_foo,pxl \
; RUN: -r=%t1.bc,_b,pxl \ ; RUN: -r=%t1.bc,_b,pxl \
; RUN: -r=%t2.bc,_main,pxl \ ; RUN: -r=%t2.bc,_main,pxl \
; RUN: -r=%t2.bc,_foo,xl ; RUN: -r=%t2.bc,_foo,xl
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
; We shouldn't promote the private because it has a section ; We shouldn't promote the private because it has a section
; RUN: llvm-dis < %t.o.1.2.internalize.bc | FileCheck %s --check-prefix=PROMOTE ; 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" ; PROMOTE: @a = private global i8 0, section "__TEXT,__cstring,cstring_literals"
@a = private global i8 0, section "__TEXT,__cstring,cstring_literals" @a = private global i8 0, section "__TEXT,__cstring,cstring_literals"
@b = global i8 *@a @b = global i8 *@a
; We want foo to be imported in the main module! ; We want foo to be imported in the main module!
; RUN: llvm-dis < %t.o.2.3.import.bc | FileCheck %s --check-prefix=IMPORT ; 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 i8** @foo()
define i8 **@foo() { define i8 **@foo() {
ret i8 **@b ret i8 **@b
} }

llvm/test/ThinLTO/X86/referenced_by_constant.ll

Show All 15 Lines
; Check the export side: we currently only export bar(), which causes ; Check the export side: we currently only export bar(), which causes
; @someglobal and @someglobal2 to be promoted (see above). ; @someglobal and @someglobal2 to be promoted (see above).
; RUN: llvm-lto -thinlto-action=promote %t2.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=EXPORT ; RUN: llvm-lto -thinlto-action=promote %t2.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=EXPORT
; EXPORT: @someglobal.llvm.0 = hidden unnamed_addr constant ; EXPORT: @someglobal.llvm.0 = hidden unnamed_addr constant
; EXPORT: @someglobal2.llvm.0 = hidden unnamed_addr constant ; EXPORT: @someglobal2.llvm.0 = hidden unnamed_addr constant
; EXPORT: define void @referencedbyglobal() ; EXPORT: define void @referencedbyglobal()
; EXPORT: define internal void @localreferencedbyglobal() ; EXPORT: define internal void @localreferencedbyglobal()
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
declare void @bar() declare void @bar()
define void @foo() { define void @foo() {
call void @bar() call void @bar()
ret void ret void
} }

llvm/test/ThinLTO/X86/save_objects.ll

Show All 18 Lines
; RUN: llvm-lto -thinlto-save-objects=%t.thin.out -thinlto-action=run %t2.bc %t.bc -exported-symbol=main -thinlto-cache-dir %t.cache ; RUN: llvm-lto -thinlto-save-objects=%t.thin.out -thinlto-action=run %t2.bc %t.bc -exported-symbol=main -thinlto-cache-dir %t.cache
; RUN: ls %t.thin.out | count 2 ; RUN: ls %t.thin.out | count 2
; RUN: ls %t.cache | count 3 ; RUN: ls %t.cache | count 3
; Check the name of object in directory has arch name included. ; Check the name of object in directory has arch name included.
; RUN: ls %t.thin.out | grep x86_64.thinlto.o | count 2 ; RUN: ls %t.thin.out | grep x86_64.thinlto.o | count 2
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define void @globalfunc() #0 { define void @globalfunc() #0 {
entry: entry:
ret void ret void
} }

llvm/test/ThinLTO/X86/strong_non_prevailing.ll

; RUN: opt -module-summary %s -o %t.bc ; RUN: opt -module-summary %s -o %t.bc
; RUN: opt -module-summary %p/Inputs/strong_non_prevailing.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/strong_non_prevailing.ll -o %t2.bc
; RUN: llvm-lto -thinlto-action=run %t.bc %t2.bc -exported-symbol=__llvm_profile_filename ; RUN: llvm-lto -thinlto-action=run %t.bc %t2.bc -exported-symbol=__llvm_profile_filename
; RUN: llvm-nm -o - < %t.bc.thinlto.o | FileCheck %s --check-prefix=EXPORTED ; RUN: llvm-nm -o - < %t.bc.thinlto.o | FileCheck %s --check-prefix=EXPORTED
; RUN: llvm-nm -o - < %t2.bc.thinlto.o 2>&1 | FileCheck %s --check-prefix=NOT_EXPORTED ; RUN: llvm-nm -o - < %t2.bc.thinlto.o 2>&1 | FileCheck %s --check-prefix=NOT_EXPORTED
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
$__llvm_profile_filename = comdat any $__llvm_profile_filename = comdat any
@__llvm_profile_filename = constant [19 x i8] c"default_%m.profraw\00", comdat @__llvm_profile_filename = constant [19 x i8] c"default_%m.profraw\00", comdat
; EXPORTED: R __llvm_profile_filename ; EXPORTED: R __llvm_profile_filename
; NOT_EXPORTED-NOT: R __llvm_profile_filename ; NOT_EXPORTED-NOT: R __llvm_profile_filename

llvm/test/ThinLTO/X86/thinlto-internalize-used.ll

; RUN: opt -module-summary -o %t.bc %s ; RUN: opt -module-summary -o %t.bc %s
; RUN: opt -module-summary -o %t-main.bc %S/Inputs/thinlto-internalize-used2.ll ; RUN: opt -module-summary -o %t-main.bc %S/Inputs/thinlto-internalize-used2.ll
; RUN: llvm-lto -thinlto-action=thinlink %t.bc %t-main.bc -o %t-index.bc ; RUN: llvm-lto -thinlto-action=thinlink %t.bc %t-main.bc -o %t-index.bc
; RUN: llvm-lto -thinlto-action=internalize -thinlto-index %t-index.bc %t.bc -o %t.promote.bc ; RUN: llvm-lto -thinlto-action=internalize -thinlto-index %t-index.bc %t.bc -o %t.promote.bc
; RUN: llvm-dis %t.promote.bc -o - | FileCheck %s ; RUN: llvm-dis %t.promote.bc -o - | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.15.0" target triple = "x86_64-apple-macosx10.15.0"
@llvm.used = appending global [1 x i8*] [i8* bitcast (i32 ()* @foo to i8*)], section "llvm.metadata" @llvm.used = appending global [1 x i8*] [i8* bitcast (i32 ()* @foo to i8*)], section "llvm.metadata"
; Make sure foo is not internalized. ; Make sure foo is not internalized.
; CHECK: define i32 @foo() ; CHECK: define i32 @foo()
define i32 @foo() { define i32 @foo() {
ret i32 0 ret i32 0
} }
define hidden i32 @bar() { define hidden i32 @bar() {
ret i32 0 ret i32 0
} }

llvm/test/ThinLTO/X86/tli-nobuiltin.ll

Show All 19 Lines
; ThinLTO: fwrite ; ThinLTO: fwrite
; Freestanding run: expects fprintf to NOT be turned into fwrite ; Freestanding run: expects fprintf to NOT be turned into fwrite
; RUN: llvm-lto -lto-freestanding -exported-symbol=_foo -thinlto-action=run %t.bc ; RUN: llvm-lto -lto-freestanding -exported-symbol=_foo -thinlto-action=run %t.bc
; RUN: llvm-nm %t.bc.thinlto.o | FileCheck %s --check-prefix=ThinLTO-FREESTANDING ; RUN: llvm-nm %t.bc.thinlto.o | FileCheck %s --check-prefix=ThinLTO-FREESTANDING
; ThinLTO-FREESTANDING: fprintf ; ThinLTO-FREESTANDING: fprintf
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
declare i32 @fprintf(%FILE*, i8*, ...) declare i32 @fprintf(%FILE*, i8*, ...)
%FILE = type { } %FILE = type { }
@hello_world = constant [13 x i8] c"hello world\0A\00" @hello_world = constant [13 x i8] c"hello world\0A\00"
@percent_s = constant [3 x i8] c"%s\00" @percent_s = constant [3 x i8] c"%s\00"
Show All 10 Lines

llvm/test/ThinLTO/X86/weak_externals.ll

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

llvm/test/ThinLTO/X86/weak_resolution.ll

; Do setup work for all below tests: generate bitcode and combined index ; Do setup work for all below tests: generate bitcode and combined index
; RUN: opt -module-summary %s -o %t.bc ; RUN: opt -module-summary %s -o %t.bc
; RUN: opt -module-summary %p/Inputs/weak_resolution.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/weak_resolution.ll -o %t2.bc
; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc ; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc
; Verify that prevailing weak for linker symbol is selected across modules, ; Verify that prevailing weak for linker symbol is selected across modules,
; non-prevailing ODR are not kept when possible, but non-ODR non-prevailing ; non-prevailing ODR are not kept when possible, but non-ODR non-prevailing
; are not affected. ; are not affected.
; RUN: llvm-lto -thinlto-action=promote %t.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=MOD1 ; RUN: llvm-lto -thinlto-action=promote %t.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=MOD1
; RUN: llvm-lto -thinlto-action=internalize %t.bc -thinlto-index=%t3.bc -exported-symbol=linkoncefunc -o - | llvm-dis -o - | FileCheck %s --check-prefix=MOD1-INT ; RUN: llvm-lto -thinlto-action=internalize %t.bc -thinlto-index=%t3.bc -exported-symbol=linkoncefunc -o - | llvm-dis -o - | FileCheck %s --check-prefix=MOD1-INT
; RUN: llvm-lto -thinlto-action=promote %t2.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=MOD2 ; RUN: llvm-lto -thinlto-action=promote %t2.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=MOD2
; When exported, we always preserve a linkonce ; When exported, we always preserve a linkonce
; RUN: llvm-lto -thinlto-action=promote %t.bc -thinlto-index=%t3.bc -o - --exported-symbol=linkonceodrfuncInSingleModule | llvm-dis -o - | FileCheck %s --check-prefix=EXPORTED ; RUN: llvm-lto -thinlto-action=promote %t.bc -thinlto-index=%t3.bc -o - --exported-symbol=linkonceodrfuncInSingleModule | llvm-dis -o - | FileCheck %s --check-prefix=EXPORTED
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
; Alias are resolved, but can't be turned into "available_externally" ; Alias are resolved, but can't be turned into "available_externally"
; MOD1: @linkonceodralias = weak_odr alias void (), void ()* @linkonceodrfuncwithalias ; MOD1: @linkonceodralias = weak_odr alias void (), void ()* @linkonceodrfuncwithalias
; MOD2: @linkonceodralias = linkonce_odr alias void (), void ()* @linkonceodrfuncwithalias ; MOD2: @linkonceodralias = linkonce_odr alias void (), void ()* @linkonceodrfuncwithalias
@linkonceodralias = linkonce_odr alias void (), void ()* @linkonceodrfuncwithalias @linkonceodralias = linkonce_odr alias void (), void ()* @linkonceodrfuncwithalias
; Alias are resolved, but can't be turned into "available_externally" ; Alias are resolved, but can't be turned into "available_externally"
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/test/ThinLTO/X86/writeonly.ll

Show All 19 Lines
; Check that we've optimized out variables and corresponding stores ; Check that we've optimized out variables and corresponding stores
; OPTIMIZE-NOT: gFoo ; OPTIMIZE-NOT: gFoo
; OPTIMIZE-NOT: gBar ; OPTIMIZE-NOT: gBar
; OPTIMIZE: i32 @main ; OPTIMIZE: i32 @main
; OPTIMIZE-NEXT: %1 = tail call i32 @rand() ; OPTIMIZE-NEXT: %1 = tail call i32 @rand()
; OPTIMIZE-NEXT: %2 = tail call i32 @rand() ; OPTIMIZE-NEXT: %2 = tail call i32 @rand()
; OPTIMIZE-NEXT: ret i32 0 ; OPTIMIZE-NEXT: ret i32 0
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
@gBar = external global i32 @gBar = external global i32
; Should not be counted in the stats of live write only variables since it is ; Should not be counted in the stats of live write only variables since it is
; dead and will be dropped anyway. ; dead and will be dropped anyway.
@gDead = internal unnamed_addr global i32 1, align 4 @gDead = internal unnamed_addr global i32 1, align 4
define i32 @main() local_unnamed_addr { define i32 @main() local_unnamed_addr {
tail call void @baz() tail call void @baz()
ret i32 0 ret i32 0
} }
declare void @baz() local_unnamed_addr declare void @baz() local_unnamed_addr

llvm/test/ThinLTO/X86/writeonly2.ll

Show All 31 Lines
; CODEGEN-SRC-NOT: gFoo ; CODEGEN-SRC-NOT: gFoo
; CODEGEN-SRC-NOT: gBar ; CODEGEN-SRC-NOT: gBar
; CODEGEN-SRC: void @baz() ; CODEGEN-SRC: void @baz()
; CODEGEN-SRC-NEXT: %1 = tail call i32 @rand() ; CODEGEN-SRC-NEXT: %1 = tail call i32 @rand()
; CODEGEN-SRC-NEXT: %2 = tail call i32 @rand() ; CODEGEN-SRC-NEXT: %2 = tail call i32 @rand()
; CODEGEN-SRC-NEXT: ret void ; CODEGEN-SRC-NEXT: ret void
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; We should be able to link external definition of gBar to its declaration ; We should be able to link external definition of gBar to its declaration
@gBar = external global i32 @gBar = external global i32
define i32 @main() local_unnamed_addr { define i32 @main() local_unnamed_addr {
tail call void @baz() tail call void @baz()
ret i32 0 ret i32 0
} }
declare void @baz() local_unnamed_addr declare void @baz() local_unnamed_addr

llvm/test/Transforms/FunctionImport/Inputs/comdat.ll

target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.0.24215" target triple = "x86_64-pc-windows-msvc19.0.24215"
define void @main() { define void @main() {
entry: entry:
call i8* @lwt_fun() call i8* @lwt_fun()
ret void ret void
} }
declare i8* @lwt_fun() declare i8* @lwt_fun()

llvm/test/Transforms/FunctionImport/Inputs/funcimport_debug.ll

; ModuleID = 'funcimport_debug.o' ; ModuleID = 'funcimport_debug.o'
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @func() #0 !dbg !4 { define void @func() #0 !dbg !4 {
entry: entry:
ret void, !dbg !10 ret void, !dbg !10
} }
Show All 16 Lines

llvm/test/Transforms/FunctionImport/Inputs/funcimport_resolved1.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define void @foo() { define void @foo() {
call void @linkonceodrfunc() call void @linkonceodrfunc()
call void @linkonceodrfunc2() call void @linkonceodrfunc2()
ret void ret void
} }
Show All 25 Lines

llvm/test/Transforms/FunctionImport/Inputs/funcimport_resolved2.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define linkonce_odr void @linkonceodrfunc() { define linkonce_odr void @linkonceodrfunc() {
ret void ret void
} }

llvm/test/Transforms/FunctionImport/Inputs/funcimport_var2.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@link = internal global i32 0, align 4 @link = internal global i32 0, align 4
; Function Attrs: norecurse nounwind readnone uwtable ; Function Attrs: norecurse nounwind readnone uwtable
define nonnull i32* @get_link() local_unnamed_addr { define nonnull i32* @get_link() local_unnamed_addr {
ret i32* @link ret i32* @link
} }

llvm/test/Transforms/FunctionImport/Inputs/hotness_based_import.ll

; ModuleID = 'thinlto-function-summary-callgraph-profile-summary2.ll' ; ModuleID = 'thinlto-function-summary-callgraph-profile-summary2.ll'
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @hot1() #1 { define void @hot1() #1 {
ret void ret void
} }
define void @hot2() #1 !prof !20 { define void @hot2() #1 !prof !20 {
call void @calledFromHot() call void @calledFromHot()
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
!7 = !{!"MaxFunctionCount", i64 1000} !7 = !{!"MaxFunctionCount", i64 1000}
!8 = !{!"NumCounts", i64 3} !8 = !{!"NumCounts", i64 3}
!9 = !{!"NumFunctions", i64 3} !9 = !{!"NumFunctions", i64 3}
!10 = !{!"DetailedSummary", !11} !10 = !{!"DetailedSummary", !11}
!11 = !{!12, !13, !14} !11 = !{!12, !13, !14}
!12 = !{i32 10000, i64 100, i32 1} !12 = !{i32 10000, i64 100, i32 1}
!13 = !{i32 999000, i64 100, i32 1} !13 = !{i32 999000, i64 100, i32 1}
!14 = !{i32 999999, i64 1, i32 2} !14 = !{i32 999999, i64 1, i32 2}
No newline at end of file No newline at end of file

llvm/test/Transforms/FunctionImport/Inputs/import_stats.ll

; ModuleID = 'import_stats2.ll' ; ModuleID = 'import_stats2.ll'
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@globalvar = global i32 1, align 4 @globalvar = global i32 1, align 4
define void @hot() { define void @hot() {
store i32 0, i32* @globalvar, align 4 store i32 0, i32* @globalvar, align 4
ret void ret void
} }
define void @critical() { define void @critical() {
ret void ret void
} }
define void @none() { define void @none() {
ret void ret void
} }

llvm/test/Transforms/FunctionImport/Inputs/not-prevailing.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define weak i32 @foo() { define weak i32 @foo() {
ret i32 0 ret i32 0
} }

llvm/test/Transforms/FunctionImport/comdat.ll

; Test to ensure that comdat is renamed consistently when comdat leader is ; Test to ensure that comdat is renamed consistently when comdat leader is
; promoted and renamed due to an import. Required by COFF. ; promoted and renamed due to an import. Required by COFF.
; REQUIRES: x86-registered-target ; REQUIRES: x86-registered-target
; RUN: opt -thinlto-bc -o %t1.bc %s ; RUN: opt -thinlto-bc -o %t1.bc %s
; RUN: opt -thinlto-bc -o %t2.bc %S/Inputs/comdat.ll ; RUN: opt -thinlto-bc -o %t2.bc %S/Inputs/comdat.ll
; RUN: llvm-lto2 run -save-temps -o %t3 %t1.bc %t2.bc \ ; RUN: llvm-lto2 run -save-temps -o %t3 %t1.bc %t2.bc \
; RUN: -r %t1.bc,lwt_fun,plx \ ; RUN: -r %t1.bc,lwt_fun,plx \
; RUN: -r %t2.bc,main,plx \ ; RUN: -r %t2.bc,main,plx \
; RUN: -r %t2.bc,lwt_fun, ; RUN: -r %t2.bc,lwt_fun,
; RUN: llvm-dis -o - %t3.1.3.import.bc | FileCheck %s ; RUN: llvm-dis -o - %t3.1.3.import.bc | FileCheck %s
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.0.24215" target triple = "x86_64-pc-windows-msvc19.0.24215"
; CHECK: $lwt.llvm.[[HASH:[0-9]+]] = comdat any ; CHECK: $lwt.llvm.[[HASH:[0-9]+]] = comdat any
$lwt = comdat any $lwt = comdat any
; CHECK: @lwt_aliasee = private unnamed_addr global {{.*}}, comdat($lwt.llvm.[[HASH]]) ; CHECK: @lwt_aliasee = private unnamed_addr global {{.*}}, comdat($lwt.llvm.[[HASH]])
@lwt_aliasee = private unnamed_addr global [1 x i8*] [i8* null], comdat($lwt) @lwt_aliasee = private unnamed_addr global [1 x i8*] [i8* null], comdat($lwt)
Show All 10 Lines

llvm/test/Transforms/FunctionImport/funcimport_debug.ll

Show All 14 Lines
; CHECK: ![[CU2:[0-9]+]] = distinct !DICompileUnit( ; CHECK: ![[CU2:[0-9]+]] = distinct !DICompileUnit(
; CHECK: distinct !DISubprogram(name: "main" ; CHECK: distinct !DISubprogram(name: "main"
; CHECK-SAME: unit: ![[CU1]] ; CHECK-SAME: unit: ![[CU1]]
; CHECK: distinct !DISubprogram(name: "func" ; CHECK: distinct !DISubprogram(name: "func"
; CHECK-SAME: unit: ![[CU2]] ; CHECK-SAME: unit: ![[CU2]]
; CHECK-NOT: distinct !DISubprogram ; CHECK-NOT: distinct !DISubprogram
; ModuleID = 'funcimport_debug.o' ; ModuleID = 'funcimport_debug.o'
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define i32 @main() #0 !dbg !4 { define i32 @main() #0 !dbg !4 {
entry: entry:
call void (...) @func(), !dbg !11 call void (...) @func(), !dbg !11
ret i32 0, !dbg !12 ret i32 0, !dbg !12
} }
Show All 22 Lines

llvm/test/Transforms/FunctionImport/funcimport_resolved.ll

Show All 32 Lines
; when it is encountered via the deeper call chain. ; when it is encountered via the deeper call chain.
; RUN: llvm-lto2 run %t.bc %t2.bc %t3.bc -o %t4 -r=%t.bc,_main,pl -r=%t.bc,_linkonceodrfunc,l -r=%t.bc,_foo,l -r=%t2.bc,_foo,pl -r=%t2.bc,_linkonceodrfunc,pl -r=%t2.bc,_linkonceodrfunc2,pl -r=%t3.bc,_linkonceodrfunc,l -thinlto-threads=1 -debug-only=function-import -import-instr-limit=8 2>&1 | FileCheck %s --check-prefix=INSTLIM8 ; RUN: llvm-lto2 run %t.bc %t2.bc %t3.bc -o %t4 -r=%t.bc,_main,pl -r=%t.bc,_linkonceodrfunc,l -r=%t.bc,_foo,l -r=%t2.bc,_foo,pl -r=%t2.bc,_linkonceodrfunc,pl -r=%t2.bc,_linkonceodrfunc2,pl -r=%t3.bc,_linkonceodrfunc,l -thinlto-threads=1 -debug-only=function-import -import-instr-limit=8 2>&1 | FileCheck %s --check-prefix=INSTLIM8
; INSTLIM8: Is importing function {{.*}} foo from {{.*}}funcimport_resolved1.ll ; INSTLIM8: Is importing function {{.*}} foo from {{.*}}funcimport_resolved1.ll
; INSTLIM8: Is importing function {{.*}} linkonceodrfunc from {{.*}}funcimport_resolved1.ll ; INSTLIM8: Is importing function {{.*}} linkonceodrfunc from {{.*}}funcimport_resolved1.ll
; INSTLIM8: Not importing function {{.*}} linkonceodrfunc2 from {{.*}}funcimport_resolved1.ll ; INSTLIM8: Not importing function {{.*}} linkonceodrfunc2 from {{.*}}funcimport_resolved1.ll
; INSTLIM8: Is importing function {{.*}} f from {{.*}}funcimport_resolved1.ll ; INSTLIM8: Is importing function {{.*}} f from {{.*}}funcimport_resolved1.ll
; INSTLIM8-NOT: Is importing function {{.*}} linkonceodrfunc from {{.*}}funcimport_resolved2.ll ; INSTLIM8-NOT: Is importing function {{.*}} linkonceodrfunc from {{.*}}funcimport_resolved2.ll
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define i32 @main() #0 { define i32 @main() #0 {
entry: entry:
call void (...) @foo() call void (...) @foo()
call void (...) @linkonceodrfunc() call void (...) @linkonceodrfunc()
ret i32 0 ret i32 0
} }
declare void @foo(...) #1 declare void @foo(...) #1
declare void @linkonceodrfunc(...) #1 declare void @linkonceodrfunc(...) #1

llvm/test/Transforms/FunctionImport/funcimport_var.ll

Show All 9 Lines
; RUN: -r %t.bc,_Z4LinkPKcS0_,plx \ ; RUN: -r %t.bc,_Z4LinkPKcS0_,plx \
; RUN: -r %t.bc,link,l \ ; RUN: -r %t.bc,link,l \
; RUN: -r %t2.bc,get_link,plx ; RUN: -r %t2.bc,get_link,plx
; RUN: llvm-nm %t.out.1 | FileCheck %s ; RUN: llvm-nm %t.out.1 | FileCheck %s
; CHECK: U link ; CHECK: U link
; REQUIRES: x86-registered-target ; REQUIRES: x86-registered-target
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i32 @_Z4LinkPKcS0_(i8*, i8*) local_unnamed_addr { define i32 @_Z4LinkPKcS0_(i8*, i8*) local_unnamed_addr {
%3 = tail call i32 @link(i8* %0, i8* %1) #2 %3 = tail call i32 @link(i8* %0, i8* %1) #2
ret i32 %3 ret i32 %3
} }
; Function Attrs: nounwind ; Function Attrs: nounwind
declare i32 @link(i8*, i8*) local_unnamed_addr declare i32 @link(i8*, i8*) local_unnamed_addr

llvm/test/Transforms/FunctionImport/hotness_based_import.ll

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
; HOT-ZERO-NOT: define available_externally void @hot2() ; HOT-ZERO-NOT: define available_externally void @hot2()
; HOT-ZERO-NOT: define available_externally void @hot1() ; HOT-ZERO-NOT: define available_externally void @hot1()
; HOT-ZERO-NOT: define available_externally void @hot3() ; HOT-ZERO-NOT: define available_externally void @hot3()
; HOT-ZERO-NOT: define available_externally void @calledFromHot() ; HOT-ZERO-NOT: define available_externally void @calledFromHot()
; HOT-ZERO-NOT: define available_externally void @calledFromHot2() ; HOT-ZERO-NOT: define available_externally void @calledFromHot2()
; ModuleID = 'thinlto-function-summary-callgraph.ll' ; ModuleID = 'thinlto-function-summary-callgraph.ll'
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; This function have high profile count, so entry block is hot. ; This function have high profile count, so entry block is hot.
define void @hot_function(i1 %a, i1 %a2) !prof !20 { define void @hot_function(i1 %a, i1 %a2) !prof !20 {
entry: entry:
call void @hot1() call void @hot1()
br i1 %a, label %Cold, label %Hot, !prof !41 br i1 %a, label %Cold, label %Hot, !prof !41
Cold: ; 1/1000 goes here Cold: ; 1/1000 goes here
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/test/Transforms/FunctionImport/import_stats.ll

Show All 22 Lines
; RUN: 2>&1 | FileCheck %s --check-prefix=THINLINKSTATS ; RUN: 2>&1 | FileCheck %s --check-prefix=THINLINKSTATS
; THINLINKSTATS-DAG: 1 function-import - Number of global variables thin link decided to import ; THINLINKSTATS-DAG: 1 function-import - Number of global variables thin link decided to import
; THINLINKSTATS-DAG: 1 function-import - Number of critical functions thin link decided to import ; THINLINKSTATS-DAG: 1 function-import - Number of critical functions thin link decided to import
; THINLINKSTATS-DAG: 3 function-import - Number of functions thin link decided to import ; THINLINKSTATS-DAG: 3 function-import - Number of functions thin link decided to import
; THINLINKSTATS-DAG: 1 function-import - Number of hot functions thin link decided to import ; THINLINKSTATS-DAG: 1 function-import - Number of hot functions thin link decided to import
; ModuleID = 'import_stats.ll' ; ModuleID = 'import_stats.ll'
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; This function has a high profile count, so entry block is hot. ; This function has a high profile count, so entry block is hot.
define void @hot_function(i1 %a) !prof !20 { define void @hot_function(i1 %a) !prof !20 {
entry: entry:
call void @hot() call void @hot()
call void @critical() call void @critical()
br i1 %a, label %None1, label %None2, !prof !42 br i1 %a, label %None1, label %None2, !prof !42
Show All 32 Lines

llvm/test/Transforms/FunctionImport/not-prevailing.ll

; RUN: opt -module-summary %s -o %t1.bc ; RUN: opt -module-summary %s -o %t1.bc
; RUN: opt -module-summary -o %t2.bc %S/Inputs/not-prevailing.ll ; RUN: opt -module-summary -o %t2.bc %S/Inputs/not-prevailing.ll
; RUN: not llvm-lto2 run -o %t3.bc %t1.bc %t2.bc -r %t1.bc,bar,px \ ; RUN: not llvm-lto2 run -o %t3.bc %t1.bc %t2.bc -r %t1.bc,bar,px \
; RUN: -r %t1.bc,foo,x -r %t2.bc,foo,x -save-temps 2>&1 | FileCheck %s ; RUN: -r %t1.bc,foo,x -r %t2.bc,foo,x -save-temps 2>&1 | FileCheck %s
; CHECK: Interposable and available_externally/linkonce_odr/weak_odr symbol ; CHECK: Interposable and available_externally/linkonce_odr/weak_odr symbol
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define available_externally i32 @foo() { define available_externally i32 @foo() {
ret i32 1 ret i32 1
} }
define i32 @bar() { define i32 @bar() {
%1 = call i32 @foo() %1 = call i32 @foo()
ret i32 %1 ret i32 %1
} }

llvm/test/Transforms/PGOProfile/Inputs/thinlto_cspgo_bar_gen.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
$__llvm_profile_filename = comdat any $__llvm_profile_filename = comdat any
$__llvm_profile_raw_version = comdat any $__llvm_profile_raw_version = comdat any
@odd = common dso_local global i32 0, align 4 @odd = common dso_local global i32 0, align 4
@even = common dso_local global i32 0, align 4 @even = common dso_local global i32 0, align 4
@__llvm_profile_filename = constant [25 x i8] c"pass2/default_%m.profraw\00", comdat @__llvm_profile_filename = constant [25 x i8] c"pass2/default_%m.profraw\00", comdat
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/Inputs/thinlto_cspgo_bar_use.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@odd = common dso_local global i32 0, align 4 @odd = common dso_local global i32 0, align 4
@even = common dso_local global i32 0, align 4 @even = common dso_local global i32 0, align 4
define dso_local void @bar(i32 %n) #0 !prof !29 { define dso_local void @bar(i32 %n) #0 !prof !29 {
entry: entry:
%call = tail call fastcc i32 @cond(i32 %n) %call = tail call fastcc i32 @cond(i32 %n)
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/Inputs/thinlto_indirect_call_promotion.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
source_filename = "thinlto_indirect_call_promotion.c" source_filename = "thinlto_indirect_call_promotion.c"
define void @a() { define void @a() {
entry: entry:
ret void ret void
} }
define internal void @c() !PGOFuncName !1 { define internal void @c() !PGOFuncName !1 {
entry: entry:
ret void ret void
} }
!1 = !{!"thinlto_indirect_call_promotion.c:c"} !1 = !{!"thinlto_indirect_call_promotion.c:c"}

llvm/test/Transforms/PGOProfile/Inputs/thinlto_samplepgo_icp.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@fptr = external local_unnamed_addr global void ()*, align 8 @fptr = external local_unnamed_addr global void ()*, align 8
; Function Attrs: norecurse nounwind uwtable ; Function Attrs: norecurse nounwind uwtable
define void @_Z6updatei(i32 %i) local_unnamed_addr #0 { define void @_Z6updatei(i32 %i) local_unnamed_addr #0 {
entry: entry:
store void ()* @_ZL3foov, void ()** @fptr, align 8 store void ()* @_ZL3foov, void ()** @fptr, align 8
Show All 18 Lines

llvm/test/Transforms/PGOProfile/Inputs/thinlto_samplepgo_icp2a.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: norecurse nounwind readnone uwtable ; Function Attrs: norecurse nounwind readnone uwtable
define internal void @_ZL3foov() #1 { define internal void @_ZL3foov() #1 {
entry: entry:
call void @_ZL3barv() call void @_ZL3barv()
ret void ret void
} }
Show All 12 Lines

llvm/test/Transforms/PGOProfile/Inputs/thinlto_samplepgo_icp2b.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @_ZL3barv() #1 { define void @_ZL3barv() #1 {
entry: entry:
call void @dummy() call void @dummy()
call void @dummy() call void @dummy()
call void @dummy() call void @dummy()
call void @dummy() call void @dummy()
Show All 19 Lines

llvm/test/Transforms/PGOProfile/Inputs/thinlto_samplepgo_icp3.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@fptr = external local_unnamed_addr global void ()*, align 8 @fptr = external local_unnamed_addr global void ()*, align 8
; Function Attrs: norecurse nounwind uwtable ; Function Attrs: norecurse nounwind uwtable
define void @_Z6updatei(i32 %i) local_unnamed_addr #0 { define void @_Z6updatei(i32 %i) local_unnamed_addr #0 {
entry: entry:
store void ()* @_ZL3foov, void ()** @fptr, align 8 store void ()* @_ZL3foov, void ()** @fptr, align 8
Show All 22 Lines

llvm/test/Transforms/PGOProfile/X86/macho.ll

; RUN: opt < %s -pgo-instr-gen -instrprof -S | llc | FileCheck %s --check-prefix=MACHO-DIRECTIVE ; RUN: opt < %s -pgo-instr-gen -instrprof -S | llc | FileCheck %s --check-prefix=MACHO-DIRECTIVE
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
; MACHO-DIRECTIVE: .weak_definition ___llvm_profile_raw_version ; MACHO-DIRECTIVE: .weak_definition ___llvm_profile_raw_version
define i32 @test_macho(i32 %i) { define i32 @test_macho(i32 %i) {
entry: entry:
ret i32 %i ret i32 %i
} }

llvm/test/Transforms/PGOProfile/branch1.ll

Show All 12 Lines
; New PM ; New PM
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.l.profdata -S | FileCheck %s --check-prefix=USE-LARGE ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.l.profdata -S | FileCheck %s --check-prefix=USE-LARGE
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -pass-remarks=pgo-instrumentation -pgo-emit-branch-prob -S 2>&1| FileCheck %s --check-prefix=ANALYSIS ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -pass-remarks=pgo-instrumentation -pgo-emit-branch-prob -S 2>&1| FileCheck %s --check-prefix=ANALYSIS
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -pass-remarks=pgo-instrumentation -pgo-emit-branch-prob -S 2>&1| FileCheck %s --check-prefix=ANALYSIS ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -pass-remarks=pgo-instrumentation -pgo-emit-branch-prob -S 2>&1| FileCheck %s --check-prefix=ANALYSIS
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; GEN-DARWIN-LINKONCE: target triple = "x86_64-apple-darwin" ; GEN-DARWIN-LINKONCE: target triple = "x86_64-apple-darwin"
; GEN-COMDAT: $__llvm_profile_raw_version = comdat any ; GEN-COMDAT: $__llvm_profile_raw_version = comdat any
; GEN-COMDAT: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat ; GEN-COMDAT: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat
; GEN-LINKONCE: @__llvm_profile_raw_version = linkonce constant i64 {{[0-9]+}} ; GEN-LINKONCE: @__llvm_profile_raw_version = linkonce constant i64 {{[0-9]+}}
; GEN: @__profn_test_br_1 = private constant [9 x i8] c"test_br_1" ; GEN: @__profn_test_br_1 = private constant [9 x i8] c"test_br_1"
Show All 33 Lines

llvm/test/Transforms/PGOProfile/branch2.ll

; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
; RUN: llvm-profdata merge %S/Inputs/branch2.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/branch2.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; GEN: $__llvm_profile_raw_version = comdat any ; GEN: $__llvm_profile_raw_version = comdat any
; GEN: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat ; GEN: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat
; GEN: @__profn_test_br_2 = private constant [9 x i8] c"test_br_2" ; GEN: @__profn_test_br_2 = private constant [9 x i8] c"test_br_2"
define i32 @test_br_2(i32 %i) { define i32 @test_br_2(i32 %i) {
entry: entry:
Show All 27 Lines

llvm/test/Transforms/PGOProfile/comdat_internal.ll

; RUN: opt < %s -pgo-instr-gen -instrprof -S | FileCheck %s ; RUN: opt < %s -pgo-instr-gen -instrprof -S | FileCheck %s
; RUN: opt < %s -passes=pgo-instr-gen,instrprof -S | FileCheck %s ; RUN: opt < %s -passes=pgo-instr-gen,instrprof -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
$foo = comdat any $foo = comdat any
; CHECK: $foo = comdat any ; CHECK: $foo = comdat any
; CHECK: $__llvm_profile_raw_version = comdat any ; CHECK: $__llvm_profile_raw_version = comdat any
; CHECK: $__profv__stdin__foo.[[FOO_HASH:[0-9]+]] = comdat any ; CHECK: $__profv__stdin__foo.[[FOO_HASH:[0-9]+]] = comdat any
Show All 15 Lines

llvm/test/Transforms/PGOProfile/criticaledge.ll

; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
; RUN: llvm-profdata merge %S/Inputs/criticaledge.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/criticaledge.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; GEN: $__llvm_profile_raw_version = comdat any ; GEN: $__llvm_profile_raw_version = comdat any
; GEN: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat ; GEN: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat
; GEN: @__profn_test_criticalEdge = private constant [17 x i8] c"test_criticalEdge" ; GEN: @__profn_test_criticalEdge = private constant [17 x i8] c"test_criticalEdge"
; GEN: @__profn__stdin__bar = private constant [11 x i8] c"<stdin>:bar" ; GEN: @__profn__stdin__bar = private constant [11 x i8] c"<stdin>:bar"
define i32 @test_criticalEdge(i32 %i, i32 %j) { define i32 @test_criticalEdge(i32 %i, i32 %j) {
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/cspgo_profile_summary.ll

; Test the profile summary for context sensitive PGO (CSPGO) ; Test the profile summary for context sensitive PGO (CSPGO)
; RUN: llvm-profdata merge %S/Inputs/cspgo.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/cspgo.proftext -o %t.profdata
; RUN: opt < %s -O2 -disable-preinline -pgo-kind=pgo-instr-use-pipeline -profile-file=%t.profdata -S | FileCheck %s --check-prefix=PGOSUMMARY ; RUN: opt < %s -O2 -disable-preinline -pgo-kind=pgo-instr-use-pipeline -profile-file=%t.profdata -S | FileCheck %s --check-prefix=PGOSUMMARY
; RUN: opt < %s -O2 -disable-preinline -pgo-kind=pgo-instr-use-pipeline -profile-file=%t.profdata -S -cspgo-kind=cspgo-instr-use-pipeline| FileCheck %s --check-prefix=CSPGOSUMMARY ; RUN: opt < %s -O2 -disable-preinline -pgo-kind=pgo-instr-use-pipeline -profile-file=%t.profdata -S -cspgo-kind=cspgo-instr-use-pipeline| FileCheck %s --check-prefix=CSPGOSUMMARY
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@odd = common dso_local global i32 0, align 4 @odd = common dso_local global i32 0, align 4
@even = common dso_local global i32 0, align 4 @even = common dso_local global i32 0, align 4
@not_six = common dso_local global i32 0, align 4 @not_six = common dso_local global i32 0, align 4
define dso_local i32 @goo(i32 %n) { define dso_local i32 @goo(i32 %n) {
entry: entry:
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/diag_FE_profile.ll

; RUN: llvm-profdata merge %S/Inputs/diag_FE.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/diag_FE.proftext -o %t.profdata
; RUN: not opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S 2>&1 | FileCheck %s ; RUN: not opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S 2>&1 | FileCheck %s
; RUN: not opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S 2>&1 | FileCheck %s ; RUN: not opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S 2>&1 | FileCheck %s
; CHECK: Not an IR level instrumentation profile ; CHECK: Not an IR level instrumentation profile
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i32 @foo() { define i32 @foo() {
entry: entry:
ret i32 0 ret i32 0
} }

llvm/test/Transforms/PGOProfile/diag_mismatch.ll

; RUN: llvm-profdata merge %S/Inputs/diag.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/diag.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S 2>&1 | FileCheck %s ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S 2>&1 | FileCheck %s
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S 2>&1 | FileCheck %s ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S 2>&1 | FileCheck %s
; CHECK: Function control flow change detected (hash mismatch) foo ; CHECK: Function control flow change detected (hash mismatch) foo
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i32 @foo() { define i32 @foo() {
entry: entry:
ret i32 0 ret i32 0
} }

llvm/test/Transforms/PGOProfile/diag_no_funcprofdata.ll

; RUN: llvm-profdata merge %S/Inputs/diag.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/diag.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-warn-missing-function=true -pgo-test-profile-file=%t.profdata -S 2>&1 | FileCheck %s ; RUN: opt < %s -pgo-instr-use -pgo-warn-missing-function=true -pgo-test-profile-file=%t.profdata -S 2>&1 | FileCheck %s
; RUN: opt < %s -passes=pgo-instr-use -pgo-warn-missing-function=true -pgo-test-profile-file=%t.profdata -S 2>&1 | FileCheck %s ; RUN: opt < %s -passes=pgo-instr-use -pgo-warn-missing-function=true -pgo-test-profile-file=%t.profdata -S 2>&1 | FileCheck %s
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S 2>&1 | FileCheck %s --check-prefix=DEFAULT ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S 2>&1 | FileCheck %s --check-prefix=DEFAULT
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S 2>&1 | FileCheck %s --check-prefix=DEFAULT ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S 2>&1 | FileCheck %s --check-prefix=DEFAULT
; CHECK: No profile data available for function bar ; CHECK: No profile data available for function bar
; DEFAULT-NOT: No profile data available for function bar ; DEFAULT-NOT: No profile data available for function bar
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i32 @bar() { define i32 @bar() {
entry: entry:
ret i32 0 ret i32 0
} }

llvm/test/Transforms/PGOProfile/diag_no_profile.ll

; RUN: not opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S 2>&1 ; RUN: not opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S 2>&1
; RUN: not opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S 2>&1 ; RUN: not opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S 2>&1
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i32 @foo() { define i32 @foo() {
entry: entry:
ret i32 0 ret i32 0
} }

llvm/test/Transforms/PGOProfile/diag_no_value_sites.ll

; RUN: llvm-profdata merge %S/Inputs/diag_no_value_sites.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/diag_no_value_sites.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S 2>&1 | FileCheck %s ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S 2>&1 | FileCheck %s
; CHECK: Inconsistent number of value sites for memory intrinsic functions size profiling ; CHECK: Inconsistent number of value sites for memory intrinsic functions size profiling
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @foo(i8* %dst, i8* %src, i64 %n) { define void @foo(i8* %dst, i8* %src, i64 %n) {
entry: entry:
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %n, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %n, i1 false)
ret void ret void
} }
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1) declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1)

llvm/test/Transforms/PGOProfile/do-not-instrument.ll

; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s ; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s
; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s ; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.12.0" target triple = "x86_64-apple-macosx10.12.0"
define i32 @f1() { define i32 @f1() {
; CHECK-LABEL: @f1 ; CHECK-LABEL: @f1
entry: entry:
; CHECK: call void @llvm.instrprof.increment ; CHECK: call void @llvm.instrprof.increment
; CHECK-NOT: ptrtoint void (i8*)* asm sideeffect ; CHECK-NOT: ptrtoint void (i8*)* asm sideeffect
; CHECK-NOT: call void @llvm.instrprof.value.profile ; CHECK-NOT: call void @llvm.instrprof.value.profile
Show All 16 Lines

llvm/test/Transforms/PGOProfile/func_entry.ll

; RUN: llvm-profdata merge %S/Inputs/func_entry.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/func_entry.proftext -o %t.profdata
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@s = common dso_local local_unnamed_addr global i32 0, align 4 @s = common dso_local local_unnamed_addr global i32 0, align 4
define void @bar() { define void @bar() {
; CHECK-LABEL: @bar ; CHECK-LABEL: @bar
; CHECK-SAME: !prof ![[FUNC_ENTRY_COUNT_ZERO:[0-9]+]] ; CHECK-SAME: !prof ![[FUNC_ENTRY_COUNT_ZERO:[0-9]+]]
Show All 17 Lines

llvm/test/Transforms/PGOProfile/icp_covariant_call_return.ll

; RUN: opt < %s -pgo-icall-prom -S | FileCheck %s --check-prefix=ICALL-PROM ; RUN: opt < %s -pgo-icall-prom -S | FileCheck %s --check-prefix=ICALL-PROM
; RUN: opt < %s -passes=pgo-icall-prom -S | FileCheck %s --check-prefix=ICALL-PROM ; RUN: opt < %s -passes=pgo-icall-prom -S | FileCheck %s --check-prefix=ICALL-PROM
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
%struct.D = type { %struct.B } %struct.D = type { %struct.B }
%struct.B = type { i32 (...)** } %struct.B = type { i32 (...)** }
%struct.Base = type { i8 } %struct.Base = type { i8 }
%struct.Derived = type { i8 } %struct.Derived = type { i8 }
declare noalias i8* @_Znwm(i64) declare noalias i8* @_Znwm(i64)
Show All 33 Lines

llvm/test/Transforms/PGOProfile/icp_covariant_invoke_return.ll

; RUN: opt < %s -pgo-icall-prom -S | FileCheck %s --check-prefix=ICALL-PROM ; RUN: opt < %s -pgo-icall-prom -S | FileCheck %s --check-prefix=ICALL-PROM
; RUN: opt < %s -passes=pgo-icall-prom -S | FileCheck %s --check-prefix=ICALL-PROM ; RUN: opt < %s -passes=pgo-icall-prom -S | FileCheck %s --check-prefix=ICALL-PROM
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
%struct.D = type { %struct.B } %struct.D = type { %struct.B }
%struct.B = type { i32 (...)** } %struct.B = type { i32 (...)** }
%struct.Derived = type { %struct.Base, i32 } %struct.Derived = type { %struct.Base, i32 }
%struct.Base = type { i32 } %struct.Base = type { i32 }
@_ZTIi = external constant i8* @_ZTIi = external constant i8*
declare i8* @_Znwm(i64) declare i8* @_Znwm(i64)
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/icp_invoke.ll

; RUN: opt < %s -icp-lto -pgo-icall-prom -S | FileCheck %s --check-prefix=ICP ; RUN: opt < %s -icp-lto -pgo-icall-prom -S | FileCheck %s --check-prefix=ICP
; RUN: opt < %s -icp-lto -passes=pgo-icall-prom -S | FileCheck %s --check-prefix=ICP ; RUN: opt < %s -icp-lto -passes=pgo-icall-prom -S | FileCheck %s --check-prefix=ICP
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foo1 = global void ()* null, align 8 @foo1 = global void ()* null, align 8
@foo2 = global i32 ()* null, align 8 @foo2 = global i32 ()* null, align 8
@_ZTIi = external constant i8* @_ZTIi = external constant i8*
define internal void @_ZL4bar1v() !PGOFuncName !0 { define internal void @_ZL4bar1v() !PGOFuncName !0 {
entry: entry:
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/icp_invoke_nouse.ll

; RUN: opt < %s -icp-lto -pgo-icall-prom -S | FileCheck %s --check-prefix=ICP ; RUN: opt < %s -icp-lto -pgo-icall-prom -S | FileCheck %s --check-prefix=ICP
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@_ZTISt9exception = external constant i8* @_ZTISt9exception = external constant i8*
@pfptr = global i32()* null, align 8 @pfptr = global i32()* null, align 8
define internal i32 @_ZL4bar1v() !PGOFuncName !0 { define internal i32 @_ZL4bar1v() !PGOFuncName !0 {
entry: entry:
ret i32 100 ret i32 100
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/icp_mismatch_msg.ll

; RUN: opt < %s -pgo-icall-prom -pass-remarks-missed=pgo-icall-prom -S 2>& 1 | FileCheck %s ; RUN: opt < %s -pgo-icall-prom -pass-remarks-missed=pgo-icall-prom -S 2>& 1 | FileCheck %s
; RUN: opt < %s -passes=pgo-icall-prom -pass-remarks-missed=pgo-icall-prom -S 2>& 1 | FileCheck %s ; RUN: opt < %s -passes=pgo-icall-prom -pass-remarks-missed=pgo-icall-prom -S 2>& 1 | FileCheck %s
; CHECK: remark: <unknown>:0:0: Cannot promote indirect call to func4 with count of 1234: The number of arguments mismatch ; CHECK: remark: <unknown>:0:0: Cannot promote indirect call to func4 with count of 1234: The number of arguments mismatch
; CHECK: remark: <unknown>:0:0: Cannot promote indirect call: target with md5sum{{.*}} not found ; CHECK: remark: <unknown>:0:0: Cannot promote indirect call: target with md5sum{{.*}} not found
; CHECK: remark: <unknown>:0:0: Cannot promote indirect call to func2 with count of 7890: Return type mismatch ; CHECK: remark: <unknown>:0:0: Cannot promote indirect call to func2 with count of 7890: Return type mismatch
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foo = common global i32 ()* null, align 8 @foo = common global i32 ()* null, align 8
@foo2 = common global i32 ()* null, align 8 @foo2 = common global i32 ()* null, align 8
@foo3 = common global i32 ()* null, align 8 @foo3 = common global i32 ()* null, align 8
define i32 @func4(i32 %i) { define i32 @func4(i32 %i) {
entry: entry:
Show All 24 Lines

llvm/test/Transforms/PGOProfile/icp_vararg.ll

; RUN: opt < %s -pgo-icall-prom -S | FileCheck %s --check-prefix=ICALL-PROM ; RUN: opt < %s -pgo-icall-prom -S | FileCheck %s --check-prefix=ICALL-PROM
; RUN: opt < %s -passes=pgo-icall-prom -S | FileCheck %s --check-prefix=ICALL-PROM ; RUN: opt < %s -passes=pgo-icall-prom -S | FileCheck %s --check-prefix=ICALL-PROM
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foo = common global i32 (i32, ...)* null, align 8 @foo = common global i32 (i32, ...)* null, align 8
define i32 @va_func(i32 %num, ...) { define i32 @va_func(i32 %num, ...) {
entry: entry:
ret i32 0 ret i32 0
} }
Show All 22 Lines

llvm/test/Transforms/PGOProfile/indirect_call_annotation.ll

; RUN: llvm-profdata merge %S/Inputs/indirect_call.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/indirect_call.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=VP-ANNOTATION ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=VP-ANNOTATION
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=VP-ANNOTATION ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=VP-ANNOTATION
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foo = common global i32 (i32)* null, align 8 @foo = common global i32 (i32)* null, align 8
define i32 @func1(i32 %x) { define i32 @func1(i32 %x) {
entry: entry:
ret i32 %x ret i32 %x
} }
Show All 24 Lines

llvm/test/Transforms/PGOProfile/indirect_call_profile.ll

; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
; RUN: opt < %s -passes=pgo-instr-gen,instrprof -S | FileCheck %s --check-prefix=LOWER ; RUN: opt < %s -passes=pgo-instr-gen,instrprof -S | FileCheck %s --check-prefix=LOWER
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
$foo3 = comdat any $foo3 = comdat any
@bar = external global void ()*, align 8 @bar = external global void ()*, align 8
; GEN: @__profn_foo = private constant [3 x i8] c"foo" ; GEN: @__profn_foo = private constant [3 x i8] c"foo"
define void @foo() { define void @foo() {
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/indirect_call_promotion.ll

Show All 9 Lines
; PASS-REMARK: remark: <unknown>:0:0: Promote indirect call to func3 with count 150 out of 160 ; PASS-REMARK: remark: <unknown>:0:0: Promote indirect call to func3 with count 150 out of 160
; PASS-REMARK: remark: <unknown>:0:0: Promote indirect call to func1 with count 10 out of 10 ; PASS-REMARK: remark: <unknown>:0:0: Promote indirect call to func1 with count 10 out of 10
; PASS2-REMARK: remark: <unknown>:0:0: Promote indirect call to func4 with count 1030 out of 1600 ; PASS2-REMARK: remark: <unknown>:0:0: Promote indirect call to func4 with count 1030 out of 1600
; PASS2-REMARK: remark: <unknown>:0:0: Promote indirect call to func2 with count 410 out of 570 ; PASS2-REMARK: remark: <unknown>:0:0: Promote indirect call to func2 with count 410 out of 570
; PASS2-REMARK-NOT: remark: <unknown>:0:0: Promote indirect call to func3 ; PASS2-REMARK-NOT: remark: <unknown>:0:0: Promote indirect call to func3
; PASS2-REMARK-NOT: remark: <unknown>:0:0: Promote indirect call to func1 ; PASS2-REMARK-NOT: remark: <unknown>:0:0: Promote indirect call to func1
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foo = common global i32 ()* null, align 8 @foo = common global i32 ()* null, align 8
define i32 @func1() { define i32 @func1() {
entry: entry:
ret i32 0 ret i32 0
} }
Show All 39 Lines

llvm/test/Transforms/PGOProfile/indirect_call_promotion_vla.ll

; RUN: opt < %s -pgo-icall-prom -S | FileCheck %s ; RUN: opt < %s -pgo-icall-prom -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
%struct.A = type { i8 } %struct.A = type { i8 }
%struct.B = type { i8 } %struct.B = type { i8 }
@foo = common global i32 (%struct.A*, ...)* null, align 8 @foo = common global i32 (%struct.A*, ...)* null, align 8
define i32 @func1(%struct.B* %x, ...) { define i32 @func1(%struct.B* %x, ...) {
entry: entry:
Show All 17 Lines

llvm/test/Transforms/PGOProfile/indirectbr.ll

; RUN: llvm-profdata merge %S/Inputs/indirectbr.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/indirectbr.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
; New PM ; New PM
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | opt -S -analyze -branch-prob | FileCheck %s --check-prefix=BRANCHPROB ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | opt -S -analyze -branch-prob | FileCheck %s --check-prefix=BRANCHPROB
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foo.table = internal unnamed_addr constant [3 x i8*] [i8* blockaddress(@foo, %return), i8* blockaddress(@foo, %label2), i8* blockaddress(@foo, %label3)], align 16 @foo.table = internal unnamed_addr constant [3 x i8*] [i8* blockaddress(@foo, %return), i8* blockaddress(@foo, %label2), i8* blockaddress(@foo, %label3)], align 16
define i32 @foo(i32 %i) { define i32 @foo(i32 %i) {
entry: entry:
%cmp = icmp ult i32 %i, 3 %cmp = icmp ult i32 %i, 3
br i1 %cmp, label %if.then, label %return br i1 %cmp, label %if.then, label %return
Show All 35 Lines

llvm/test/Transforms/PGOProfile/landingpad.ll

; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
; RUN: llvm-profdata merge %S/Inputs/landingpad.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/landingpad.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@val = global i32 0, align 4 @val = global i32 0, align 4
@_ZTIi = external constant i8* @_ZTIi = external constant i8*
; GEN: $__llvm_profile_raw_version = comdat any ; GEN: $__llvm_profile_raw_version = comdat any
; GEN: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat ; GEN: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat
; GEN: @__profn_bar = private constant [3 x i8] c"bar" ; GEN: @__profn_bar = private constant [3 x i8] c"bar"
; GEN: @__profn_foo = private constant [3 x i8] c"foo" ; GEN: @__profn_foo = private constant [3 x i8] c"foo"
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/large_count_remarks.ll

; RUN: llvm-profdata merge %S/Inputs/large_count_remarks.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/large_count_remarks.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -pass-remarks=pgo-instrumentation -pgo-emit-branch-prob -S 2>&1| FileCheck %s --check-prefix=ANALYSIS ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -pass-remarks=pgo-instrumentation -pgo-emit-branch-prob -S 2>&1| FileCheck %s --check-prefix=ANALYSIS
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -pass-remarks=pgo-instrumentation -pgo-emit-branch-prob -S 2>&1| FileCheck %s --check-prefix=ANALYSIS ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -pass-remarks=pgo-instrumentation -pgo-emit-branch-prob -S 2>&1| FileCheck %s --check-prefix=ANALYSIS
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i32 @test(i32 %i) { define i32 @test(i32 %i) {
entry: entry:
%cmp = icmp sgt i32 %i, 0 %cmp = icmp sgt i32 %i, 0
br i1 %cmp, label %if.then, label %if.end br i1 %cmp, label %if.then, label %if.end
if.then: if.then:
Show All 9 Lines

llvm/test/Transforms/PGOProfile/loop1.ll

; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
; RUN: llvm-profdata merge %S/Inputs/loop1.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/loop1.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; GEN: $__llvm_profile_raw_version = comdat any ; GEN: $__llvm_profile_raw_version = comdat any
; GEN: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat ; GEN: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat
; GEN: @__profn_test_simple_for = private constant [15 x i8] c"test_simple_for" ; GEN: @__profn_test_simple_for = private constant [15 x i8] c"test_simple_for"
define i32 @test_simple_for(i32 %n) { define i32 @test_simple_for(i32 %n) {
entry: entry:
Show All 33 Lines

llvm/test/Transforms/PGOProfile/loop2.ll

; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
; RUN: llvm-profdata merge %S/Inputs/loop2.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/loop2.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; GEN: $__llvm_profile_raw_version = comdat any ; GEN: $__llvm_profile_raw_version = comdat any
; GEN: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat ; GEN: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat
; GEN: @__profn_test_nested_for = private constant [15 x i8] c"test_nested_for" ; GEN: @__profn_test_nested_for = private constant [15 x i8] c"test_nested_for"
define i32 @test_nested_for(i32 %r, i32 %s) { define i32 @test_nested_for(i32 %r, i32 %s) {
entry: entry:
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/memcpy.ll

; RUN: opt < %s -pgo-instr-gen -instrprof -S | FileCheck %s ; RUN: opt < %s -pgo-instr-gen -instrprof -S | FileCheck %s
; RUN: opt <%s -passes=pgo-instr-gen,instrprof -S | FileCheck %s ; RUN: opt <%s -passes=pgo-instr-gen,instrprof -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @foo(i8* %dst, i8* %src, i32* %a, i32 %n) { define void @foo(i8* %dst, i8* %src, i32* %a, i32 %n) {
entry: entry:
br label %for.cond br label %for.cond
for.cond: for.cond:
%i.0 = phi i32 [ 0, %entry ], [ %add, %for.cond1 ] %i.0 = phi i32 [ 0, %entry ], [ %add, %for.cond1 ]
Show All 24 Lines

llvm/test/Transforms/PGOProfile/memop_size_annotation.ll

; RUN: llvm-profdata merge %S/Inputs/memop_size_annotation.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/memop_size_annotation.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -memop-max-annotations=9 -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefixes=MEMOP_ANNOTATION,MEMOP_ANNOTATION9 ; RUN: opt < %s -pgo-instr-use -memop-max-annotations=9 -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefixes=MEMOP_ANNOTATION,MEMOP_ANNOTATION9
; RUN: opt < %s -passes=pgo-instr-use -memop-max-annotations=9 -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefixes=MEMOP_ANNOTATION,MEMOP_ANNOTATION9 ; RUN: opt < %s -passes=pgo-instr-use -memop-max-annotations=9 -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefixes=MEMOP_ANNOTATION,MEMOP_ANNOTATION9
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefixes=MEMOP_ANNOTATION,MEMOP_ANNOTATION4 ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefixes=MEMOP_ANNOTATION,MEMOP_ANNOTATION4
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefixes=MEMOP_ANNOTATION,MEMOP_ANNOTATION4 ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefixes=MEMOP_ANNOTATION,MEMOP_ANNOTATION4
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @foo(i8* %dst, i8* %src, i32* %a, i32 %n) { define void @foo(i8* %dst, i8* %src, i32* %a, i32 %n) {
entry: entry:
br label %for.cond br label %for.cond
for.cond: for.cond:
%i.0 = phi i32 [ 0, %entry ], [ %inc5, %for.inc4 ] %i.0 = phi i32 [ 0, %entry ], [ %inc5, %for.inc4 ]
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/memop_size_opt.ll

; RUN: opt < %s -pgo-memop-opt -verify-dom-info -pgo-memop-count-threshold=90 -pgo-memop-percent-threshold=15 -S | FileCheck %s --check-prefix=MEMOP_OPT ; RUN: opt < %s -pgo-memop-opt -verify-dom-info -pgo-memop-count-threshold=90 -pgo-memop-percent-threshold=15 -S | FileCheck %s --check-prefix=MEMOP_OPT
; RUN: opt < %s -passes=pgo-memop-opt -verify-dom-info -pgo-memop-count-threshold=90 -pgo-memop-percent-threshold=15 -S | FileCheck %s --check-prefix=MEMOP_OPT ; RUN: opt < %s -passes=pgo-memop-opt -verify-dom-info -pgo-memop-count-threshold=90 -pgo-memop-percent-threshold=15 -S | FileCheck %s --check-prefix=MEMOP_OPT
; RUN: opt < %s -pgo-memop-opt -verify-dom-info -pgo-memop-count-threshold=90 -pgo-memop-percent-threshold=15 -pass-remarks-with-hotness -pass-remarks-output=%t.opt.yaml -S | FileCheck %s --check-prefix=MEMOP_OPT ; RUN: opt < %s -pgo-memop-opt -verify-dom-info -pgo-memop-count-threshold=90 -pgo-memop-percent-threshold=15 -pass-remarks-with-hotness -pass-remarks-output=%t.opt.yaml -S | FileCheck %s --check-prefix=MEMOP_OPT
; RUN: FileCheck %s -input-file=%t.opt.yaml --check-prefix=YAML ; RUN: FileCheck %s -input-file=%t.opt.yaml --check-prefix=YAML
; RUN: opt < %s -passes=pgo-memop-opt -verify-dom-info -pgo-memop-count-threshold=90 -pgo-memop-percent-threshold=15 -pass-remarks-with-hotness -pass-remarks-output=%t.opt.yaml -S | FileCheck %s --check-prefix=MEMOP_OPT ; RUN: opt < %s -passes=pgo-memop-opt -verify-dom-info -pgo-memop-count-threshold=90 -pgo-memop-percent-threshold=15 -pass-remarks-with-hotness -pass-remarks-output=%t.opt.yaml -S | FileCheck %s --check-prefix=MEMOP_OPT
; RUN: FileCheck %s -input-file=%t.opt.yaml --check-prefix=YAML ; RUN: FileCheck %s -input-file=%t.opt.yaml --check-prefix=YAML
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @foo(i8* %dst, i8* %src, i8* %dst2, i8* %src2, i32* %a, i32 %n) !prof !27 { define void @foo(i8* %dst, i8* %src, i8* %dst2, i8* %src2, i32* %a, i32 %n) !prof !27 {
entry: entry:
br label %for.cond br label %for.cond
for.cond: for.cond:
%i.0 = phi i32 [ 0, %entry ], [ %inc5, %for.inc4 ] %i.0 = phi i32 [ 0, %entry ], [ %inc5, %for.inc4 ]
▲ Show 20 Lines • Show All 137 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/memop_size_opt_zero.ll

; Test to ensure the pgo memop optimization pass doesn't try to scale ; Test to ensure the pgo memop optimization pass doesn't try to scale
; up a value profile with a 0 count, which would lead to divide by 0. ; up a value profile with a 0 count, which would lead to divide by 0.
; RUN: opt < %s -passes=pgo-memop-opt -verify-dom-info -pgo-memop-count-threshold=1 -S | FileCheck %s --check-prefix=MEMOP_OPT ; RUN: opt < %s -passes=pgo-memop-opt -verify-dom-info -pgo-memop-count-threshold=1 -S | FileCheck %s --check-prefix=MEMOP_OPT
; RUN: opt < %s -pgo-memop-opt -verify-dom-info -pgo-memop-count-threshold=1 -S | FileCheck %s --check-prefix=MEMOP_OPT ; RUN: opt < %s -pgo-memop-opt -verify-dom-info -pgo-memop-count-threshold=1 -S | FileCheck %s --check-prefix=MEMOP_OPT
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @foo(i8* %dst, i8* %src, i64 %conv) !prof !0 { define void @foo(i8* %dst, i8* %src, i64 %conv) !prof !0 {
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %conv, i1 false), !prof !1 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %conv, i1 false), !prof !1
ret void ret void
} }
; MEMOP_OPT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %conv, i1 false), !prof !1 ; MEMOP_OPT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %conv, i1 false), !prof !1
!0 = !{!"function_entry_count", i64 1} !0 = !{!"function_entry_count", i64 1}
!1 = !{!"VP", i32 1, i64 0, i64 1, i64 0, i64 2, i64 0, i64 3, i64 0, i64 9, i64 0, i64 4, i64 0, i64 5, i64 0, i64 6, i64 0, i64 7, i64 0, i64 8, i64 0} !1 = !{!"VP", i32 1, i64 0, i64 1, i64 0, i64 2, i64 0, i64 3, i64 0, i64 9, i64 0, i64 4, i64 0, i64 5, i64 0, i64 6, i64 0, i64 7, i64 0, i64 8, i64 0}
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1) declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1)

llvm/test/Transforms/PGOProfile/multiple_hash_profile.ll

; RUN: llvm-profdata merge %S/Inputs/multiple_hash_profile.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/multiple_hash_profile.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
$_Z3fooi = comdat any $_Z3fooi = comdat any
@g2 = local_unnamed_addr global i32 (i32)* null, align 8 @g2 = local_unnamed_addr global i32 (i32)* null, align 8
define i32 @_Z3bari(i32 %i) { define i32 @_Z3bari(i32 %i) {
entry: entry:
Show All 24 Lines

llvm/test/Transforms/PGOProfile/noreturncall.ll

; RUN: llvm-profdata merge %S/Inputs/noreturncall.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/noreturncall.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
; REQUIRES: asserts ; REQUIRES: asserts
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
declare i32 @bar0(i32) declare i32 @bar0(i32)
define i32 @bar2(i32 %i) { define i32 @bar2(i32 %i) {
entry: entry:
unreachable unreachable
} }
Show All 31 Lines

llvm/test/Transforms/PGOProfile/preinline.ll

; RUN: opt < %s -O2 -pgo-kind=pgo-instr-gen-pipeline -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -O2 -pgo-kind=pgo-instr-gen-pipeline -S | FileCheck %s --check-prefix=GEN
; RUN: opt < %s -O2 -pgo-kind=pgo-instr-gen-pipeline -profile-file=default.profraw -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -O2 -pgo-kind=pgo-instr-gen-pipeline -profile-file=default.profraw -S | FileCheck %s --check-prefix=GEN
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i32 @foo(i32 %i) { define i32 @foo(i32 %i) {
entry: entry:
; GEN: %pgocount = load i64, i64* getelementptr inbounds ([1 x i64], [1 x i64]* @__profc_foo ; GEN: %pgocount = load i64, i64* getelementptr inbounds ([1 x i64], [1 x i64]* @__profc_foo
; GEN-NOT: %pgocount.i = load i64, i64* getelementptr inbounds ([1 x i64], [1 x i64]* @__profc__stdin__bar ; GEN-NOT: %pgocount.i = load i64, i64* getelementptr inbounds ([1 x i64], [1 x i64]* @__profc__stdin__bar
%call = call i32 @bar() %call = call i32 @bar()
%add = add nsw i32 %i, %call %add = add nsw i32 %i, %call
Show All 12 Lines

llvm/test/Transforms/PGOProfile/remap.ll

; RUN: llvm-profdata merge %S/Inputs/remap.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/remap.proftext -o %t.profdata
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -pgo-test-profile-remapping-file=%S/Inputs/remap.map -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -pgo-test-profile-remapping-file=%S/Inputs/remap.map -S | FileCheck %s --check-prefix=USE
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i32 @_ZN3foo3barERKN1M1XINS_6detail3quxEEE(i32 %i) { define i32 @_ZN3foo3barERKN1M1XINS_6detail3quxEEE(i32 %i) {
; USE-LABEL: @_ZN3foo3barERKN1M1XINS_6detail3quxEEE ; USE-LABEL: @_ZN3foo3barERKN1M1XINS_6detail3quxEEE
; USE-SAME: !prof ![[FUNC_ENTRY_COUNT:[0-9]+]] ; USE-SAME: !prof ![[FUNC_ENTRY_COUNT:[0-9]+]]
entry: entry:
%cmp = icmp sgt i32 %i, 0 %cmp = icmp sgt i32 %i, 0
br i1 %cmp, label %if.then, label %if.end br i1 %cmp, label %if.then, label %if.end
Show All 16 Lines

llvm/test/Transforms/PGOProfile/select1.ll

; RUN: opt < %s -pgo-instr-gen -pgo-instr-select=true -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -pgo-instr-gen -pgo-instr-select=true -S | FileCheck %s --check-prefix=GEN
; RUN: opt < %s -passes=pgo-instr-gen -pgo-instr-select=true -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -passes=pgo-instr-gen -pgo-instr-select=true -S | FileCheck %s --check-prefix=GEN
; RUN: opt < %s -pgo-instr-gen -pgo-instr-select=false -S | FileCheck %s --check-prefix=NOSELECT ; RUN: opt < %s -pgo-instr-gen -pgo-instr-select=false -S | FileCheck %s --check-prefix=NOSELECT
; RUN: opt < %s -passes=pgo-instr-gen -pgo-instr-select=false -S | FileCheck %s --check-prefix=NOSELECT ; RUN: opt < %s -passes=pgo-instr-gen -pgo-instr-select=false -S | FileCheck %s --check-prefix=NOSELECT
; RUN: llvm-profdata merge %S/Inputs/select1.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/select1.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -pgo-instr-select=true -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -pgo-instr-select=true -S | FileCheck %s --check-prefix=USE
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -pgo-instr-select=true -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -pgo-instr-select=true -S | FileCheck %s --check-prefix=USE
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i32 @test_br_2(i32 %i) { define i32 @test_br_2(i32 %i) {
entry: entry:
%cmp = icmp sgt i32 %i, 0 %cmp = icmp sgt i32 %i, 0
br i1 %cmp, label %if.then, label %if.else br i1 %cmp, label %if.then, label %if.else
if.then: if.then:
Show All 18 Lines

llvm/test/Transforms/PGOProfile/select2.ll

; RUN: llvm-profdata merge %S/Inputs/select2.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/select2.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -pgo-instr-select=true -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -pgo-instr-select=true -S | FileCheck %s --check-prefix=USE
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -pgo-instr-select=true -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -pgo-instr-select=true -S | FileCheck %s --check-prefix=USE
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define i32 @foo(i32 %n) { define i32 @foo(i32 %n) {
;USE: define i32 @foo(i32 %n) !prof ![[ENTRY_COUNT:[0-9]+]] { ;USE: define i32 @foo(i32 %n) !prof ![[ENTRY_COUNT:[0-9]+]] {
entry: entry:
br label %for.cond br label %for.cond
for.cond: for.cond:
Show All 24 Lines

llvm/test/Transforms/PGOProfile/select_hash_conflict.ll

; RUN: llvm-profdata merge %S/Inputs/select_hash_conflict.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/select_hash_conflict.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -pgo-instr-select=true -S | FileCheck %s ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -pgo-instr-select=true -S | FileCheck %s
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -pgo-instr-select=true -S | FileCheck %s ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -pgo-instr-select=true -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@a = common dso_local local_unnamed_addr global [16 x i32] zeroinitializer, align 16 @a = common dso_local local_unnamed_addr global [16 x i32] zeroinitializer, align 16
@c0 = common dso_local local_unnamed_addr global i8 0, align 1 @c0 = common dso_local local_unnamed_addr global i8 0, align 1
@c1 = common dso_local local_unnamed_addr global i8 0, align 1 @c1 = common dso_local local_unnamed_addr global i8 0, align 1
@c2 = common dso_local local_unnamed_addr global i8 0, align 1 @c2 = common dso_local local_unnamed_addr global i8 0, align 1
@c3 = common dso_local local_unnamed_addr global i8 0, align 1 @c3 = common dso_local local_unnamed_addr global i8 0, align 1
@c4 = common dso_local local_unnamed_addr global i8 0, align 1 @c4 = common dso_local local_unnamed_addr global i8 0, align 1
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/single_bb.ll

; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; GEN: $__llvm_profile_raw_version = comdat any ; GEN: $__llvm_profile_raw_version = comdat any
; GEN: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat ; GEN: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat
; GEN: @__profn_single_bb = private constant [9 x i8] c"single_bb" ; GEN: @__profn_single_bb = private constant [9 x i8] c"single_bb"
define i32 @single_bb() { define i32 @single_bb() {
entry: entry:
; GEN: entry: ; GEN: entry:
; GEN: call void @llvm.instrprof.increment(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__profn_single_bb, i32 0, i32 0), i64 12884901887, i32 1, i32 0) ; GEN: call void @llvm.instrprof.increment(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__profn_single_bb, i32 0, i32 0), i64 12884901887, i32 1, i32 0)
ret i32 0 ret i32 0
} }

llvm/test/Transforms/PGOProfile/statics_counter_naming.ll

; RUN: opt %s -pgo-instr-gen -static-func-full-module-prefix=false -S | FileCheck %s --check-prefix=NOPATH ; RUN: opt %s -pgo-instr-gen -static-func-full-module-prefix=false -S | FileCheck %s --check-prefix=NOPATH
; RUN: opt %s -passes=pgo-instr-gen -static-func-full-module-prefix=false -S | FileCheck %s --check-prefix=NOPATH ; RUN: opt %s -passes=pgo-instr-gen -static-func-full-module-prefix=false -S | FileCheck %s --check-prefix=NOPATH
; RUN: opt %s --pgo-instr-gen -static-func-strip-dirname-prefix=1000 -S | FileCheck %s --check-prefix=NOPATH ; RUN: opt %s --pgo-instr-gen -static-func-strip-dirname-prefix=1000 -S | FileCheck %s --check-prefix=NOPATH
; RUN: opt %s -passes=pgo-instr-gen -static-func-strip-dirname-prefix=1000 -S | FileCheck %s --check-prefix=NOPATH ; RUN: opt %s -passes=pgo-instr-gen -static-func-strip-dirname-prefix=1000 -S | FileCheck %s --check-prefix=NOPATH
; RUN: opt %s --pgo-instr-gen -static-func-strip-dirname-prefix=1 -S | FileCheck %s --check-prefix=HASPATH ; RUN: opt %s --pgo-instr-gen -static-func-strip-dirname-prefix=1 -S | FileCheck %s --check-prefix=HASPATH
; RUN: opt %s -passes=pgo-instr-gen -static-func-strip-dirname-prefix=1 -S | FileCheck %s --check-prefix=HASPATH ; RUN: opt %s -passes=pgo-instr-gen -static-func-strip-dirname-prefix=1 -S | FileCheck %s --check-prefix=HASPATH
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; NOPATH: @__profn_statics_counter_naming.ll_func = private constant [30 x i8] c"statics_counter_naming.ll:func" ; NOPATH: @__profn_statics_counter_naming.ll_func = private constant [30 x i8] c"statics_counter_naming.ll:func"
; HASPATH-NOT: @__profn_statics_counter_naming.ll_func = private constant [30 x i8] c"statics_counter_naming.ll:func" ; HASPATH-NOT: @__profn_statics_counter_naming.ll_func = private constant [30 x i8] c"statics_counter_naming.ll:func"
define internal i32 @func() { define internal i32 @func() {
entry: entry:
ret i32 0 ret i32 0
} }

llvm/test/Transforms/PGOProfile/switch.ll

; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN ; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
; RUN: llvm-profdata merge %S/Inputs/switch.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/switch.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
; GEN: $__llvm_profile_raw_version = comdat any ; GEN: $__llvm_profile_raw_version = comdat any
; GEN: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat ; GEN: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat
; GEN: @__profn_test_switch = private constant [11 x i8] c"test_switch" ; GEN: @__profn_test_switch = private constant [11 x i8] c"test_switch"
define void @test_switch(i32 %i) { define void @test_switch(i32 %i) {
entry: entry:
Show All 37 Lines

llvm/test/Transforms/PGOProfile/thinlto_cspgo_gen.ll

Show All 13 Lines
; RUN: -r=%t2.bc,__llvm_profile_filename,x \ ; RUN: -r=%t2.bc,__llvm_profile_filename,x \
; RUN: -r=%t2.bc,__llvm_profile_raw_version,x ; RUN: -r=%t2.bc,__llvm_profile_raw_version,x
; RUN: llvm-dis %t.1.4.opt.bc -o - | FileCheck %s --check-prefix=CSGEN ; RUN: llvm-dis %t.1.4.opt.bc -o - | FileCheck %s --check-prefix=CSGEN
; CSGEN: @__profc_ ; CSGEN: @__profc_
; CSGEN: @__profd_ ; CSGEN: @__profd_
source_filename = "cspgo.c" source_filename = "cspgo.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
$__llvm_profile_filename = comdat any $__llvm_profile_filename = comdat any
$__llvm_profile_raw_version = comdat any $__llvm_profile_raw_version = comdat any
@__llvm_profile_filename = constant [25 x i8] c"pass2/default_%m.profraw\00", comdat @__llvm_profile_filename = constant [25 x i8] c"pass2/default_%m.profraw\00", comdat
@__llvm_profile_raw_version = constant i64 216172782113783812, comdat @__llvm_profile_raw_version = constant i64 216172782113783812, comdat
define dso_local void @foo() #0 !prof !29 { define dso_local void @foo() #0 !prof !29 {
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/thinlto_cspgo_use.ll

Show All 12 Lines
; RUN: llvm-dis %t.1.4.opt.bc -o - | FileCheck %s --check-prefix=CSUSE ; RUN: llvm-dis %t.1.4.opt.bc -o - | FileCheck %s --check-prefix=CSUSE
; CSUSE: {{![0-9]+}} = !{i32 1, !"ProfileSummary", {{![0-9]+}}} ; CSUSE: {{![0-9]+}} = !{i32 1, !"ProfileSummary", {{![0-9]+}}}
; CSUSE: {{![0-9]+}} = !{i32 1, !"CSProfileSummary", {{![0-9]+}}} ; CSUSE: {{![0-9]+}} = !{i32 1, !"CSProfileSummary", {{![0-9]+}}}
; CSUSE-DAG: {{![0-9]+}} = !{!"branch_weights", i32 100000, i32 0} ; CSUSE-DAG: {{![0-9]+}} = !{!"branch_weights", i32 100000, i32 0}
; CSUSE-DAG: {{![0-9]+}} = !{!"branch_weights", i32 0, i32 100000} ; CSUSE-DAG: {{![0-9]+}} = !{!"branch_weights", i32 0, i32 100000}
source_filename = "cspgo.c" source_filename = "cspgo.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define dso_local void @foo() #0 !prof !29 { define dso_local void @foo() #0 !prof !29 {
entry: entry:
br label %for.body br label %for.body
for.body: for.body:
%i.06 = phi i32 [ 0, %entry ], [ %add1, %for.body ] %i.06 = phi i32 [ 0, %entry ], [ %add1, %for.body ]
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/thinlto_indirect_call_promotion.ll

; Do setup work for all below tests: generate bitcode and combined index ; Do setup work for all below tests: generate bitcode and combined index
; RUN: opt -module-summary %s -o %t.bc ; RUN: opt -module-summary %s -o %t.bc
; RUN: opt -module-summary %p/Inputs/thinlto_indirect_call_promotion.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/thinlto_indirect_call_promotion.ll -o %t2.bc
; RUN: llvm-lto -thinlto -o %t3 %t.bc %t2.bc ; RUN: llvm-lto -thinlto -o %t3 %t.bc %t2.bc
; RUN: opt -function-import -summary-file %t3.thinlto.bc %t.bc -o %t4.bc -print-imports 2>&1 | FileCheck %s --check-prefix=IMPORTS ; RUN: opt -function-import -summary-file %t3.thinlto.bc %t.bc -o %t4.bc -print-imports 2>&1 | FileCheck %s --check-prefix=IMPORTS
; IMPORTS-DAG: Import a ; IMPORTS-DAG: Import a
; IMPORTS-DAG: Import c ; IMPORTS-DAG: Import c
; RUN: opt %t4.bc -icp-lto -pgo-icall-prom -S | FileCheck %s --check-prefix=ICALL-PROM ; RUN: opt %t4.bc -icp-lto -pgo-icall-prom -S | FileCheck %s --check-prefix=ICALL-PROM
; RUN: opt %t4.bc -icp-lto -pgo-icall-prom -S -pass-remarks=pgo-icall-prom 2>&1 | FileCheck %s --check-prefix=PASS-REMARK ; RUN: opt %t4.bc -icp-lto -pgo-icall-prom -S -pass-remarks=pgo-icall-prom 2>&1 | FileCheck %s --check-prefix=PASS-REMARK
; PASS-REMARK: Promote indirect call to a with count 1 out of 1 ; PASS-REMARK: Promote indirect call to a with count 1 out of 1
; PASS-REMARK: Promote indirect call to c.llvm.0 with count 1 out of 1 ; PASS-REMARK: Promote indirect call to c.llvm.0 with count 1 out of 1
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@foo = external local_unnamed_addr global void ()*, align 8 @foo = external local_unnamed_addr global void ()*, align 8
@bar = external local_unnamed_addr global void ()*, align 8 @bar = external local_unnamed_addr global void ()*, align 8
define i32 @main() local_unnamed_addr { define i32 @main() local_unnamed_addr {
entry: entry:
%0 = load void ()*, void ()** @foo, align 8 %0 = load void ()*, void ()** @foo, align 8
Show All 16 Lines

llvm/test/Transforms/PGOProfile/thinlto_samplepgo_icp.ll

; Do setup work for all below tests: generate bitcode and combined index ; Do setup work for all below tests: generate bitcode and combined index
; RUN: opt -module-summary %s -o %t.bc ; RUN: opt -module-summary %s -o %t.bc
; RUN: opt -module-summary %p/Inputs/thinlto_samplepgo_icp.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/thinlto_samplepgo_icp.ll -o %t2.bc
; RUN: llvm-lto -thinlto -o %t3 %t.bc %t2.bc ; RUN: llvm-lto -thinlto -o %t3 %t.bc %t2.bc
; Checks if calls to static target functions are properly imported and promoted ; Checks if calls to static target functions are properly imported and promoted
; by ICP. Note that the GUID in the profile is from the oroginal name. ; by ICP. Note that the GUID in the profile is from the oroginal name.
; RUN: opt -function-import -summary-file %t3.thinlto.bc %t.bc -o %t4.bc -print-imports 2>&1 | FileCheck %s --check-prefix=IMPORTS ; RUN: opt -function-import -summary-file %t3.thinlto.bc %t.bc -o %t4.bc -print-imports 2>&1 | FileCheck %s --check-prefix=IMPORTS
; IMPORTS: Import _ZL3foov.llvm.0 ; IMPORTS: Import _ZL3foov.llvm.0
; RUN: opt %t4.bc -icp-lto -pgo-icall-prom -S | FileCheck %s --check-prefix=ICALL-PROM ; RUN: opt %t4.bc -icp-lto -pgo-icall-prom -S | FileCheck %s --check-prefix=ICALL-PROM
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@fptr = local_unnamed_addr global void ()* null, align 8 @fptr = local_unnamed_addr global void ()* null, align 8
; Function Attrs: norecurse uwtable ; Function Attrs: norecurse uwtable
define i32 @main() local_unnamed_addr #0 !prof !34 { define i32 @main() local_unnamed_addr #0 !prof !34 {
entry: entry:
%0 = load void ()*, void ()** @fptr, align 8 %0 = load void ()*, void ()** @fptr, align 8
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/thinlto_samplepgo_icp2.ll

Show All 18 Lines
; IMPORTS2-NOT: Import _ZL3barv ; IMPORTS2-NOT: Import _ZL3barv
; IMPORTS2: Import _ZL3foov.llvm.0 ; IMPORTS2: Import _ZL3foov.llvm.0
; IMPORTS2-NOT: Import _ZL3barv ; IMPORTS2-NOT: Import _ZL3barv
; RUN: llvm-nm %t3.2 | FileCheck %s --check-prefix=NM ; RUN: llvm-nm %t3.2 | FileCheck %s --check-prefix=NM
; NM: _ZL3barv ; NM: _ZL3barv
; RUN: llvm-dis < %t3.3.2.internalize.bc | FileCheck %s --check-prefix=INTERNALIZE ; RUN: llvm-dis < %t3.3.2.internalize.bc | FileCheck %s --check-prefix=INTERNALIZE
; INTERNALIZE: define dso_local void @_ZL3barv ; INTERNALIZE: define dso_local void @_ZL3barv
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@fptr = local_unnamed_addr global void ()* null, align 8 @fptr = local_unnamed_addr global void ()* null, align 8
; Function Attrs: norecurse uwtable ; Function Attrs: norecurse uwtable
define i32 @main() local_unnamed_addr #0 !prof !34 { define i32 @main() local_unnamed_addr #0 !prof !34 {
entry: entry:
%0 = load void ()*, void ()** @fptr, align 8 %0 = load void ()*, void ()** @fptr, align 8
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/thinlto_samplepgo_icp3.ll

; REQUIRES: x86-registered-target ; REQUIRES: x86-registered-target
; Do setup work for all below tests: generate bitcode and combined index ; Do setup work for all below tests: generate bitcode and combined index
; RUN: opt -module-summary %s -o %t.bc ; RUN: opt -module-summary %s -o %t.bc
; RUN: opt -module-summary %p/Inputs/thinlto_samplepgo_icp3.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/thinlto_samplepgo_icp3.ll -o %t2.bc
; Test to make sure importing and dead stripping works in the ; Test to make sure importing and dead stripping works in the
; case where the target is a local function that also indirectly calls itself. ; case where the target is a local function that also indirectly calls itself.
; RUN: llvm-lto2 run -thinlto-threads=1 -save-temps -o %t3 %t.bc %t2.bc -r %t.bc,fptr,plx -r %t.bc,main,plx -r %t2.bc,_Z6updatei,pl -r %t2.bc,fptr,l -print-imports 2>&1 | FileCheck %s --check-prefix=IMPORTS ; RUN: llvm-lto2 run -thinlto-threads=1 -save-temps -o %t3 %t.bc %t2.bc -r %t.bc,fptr,plx -r %t.bc,main,plx -r %t2.bc,_Z6updatei,pl -r %t2.bc,fptr,l -print-imports 2>&1 | FileCheck %s --check-prefix=IMPORTS
; Make sure we import the promted indirectly called target ; Make sure we import the promted indirectly called target
; IMPORTS: Import _ZL3foov.llvm.0 ; IMPORTS: Import _ZL3foov.llvm.0
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@fptr = local_unnamed_addr global void ()* null, align 8 @fptr = local_unnamed_addr global void ()* null, align 8
; Function Attrs: norecurse uwtable ; Function Attrs: norecurse uwtable
define i32 @main() local_unnamed_addr #0 !prof !34 { define i32 @main() local_unnamed_addr #0 !prof !34 {
entry: entry:
%0 = load void ()*, void ()** @fptr, align 8 %0 = load void ()*, void ()** @fptr, align 8
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/thinlto_samplepgo_icp_droppeddead.ll

; REQUIRES: x86-registered-target ; REQUIRES: x86-registered-target
; RUN: opt -module-summary %s -o %t.bc ; RUN: opt -module-summary %s -o %t.bc
; Tests that with dead stripping in the thin link enabled (default), we do not ; Tests that with dead stripping in the thin link enabled (default), we do not
; promote to target of the dropped dead symbol _ZL3foov. This can happen with a ; promote to target of the dropped dead symbol _ZL3foov. This can happen with a
; sample profile collected for one binary used to optimize for another binary. ; sample profile collected for one binary used to optimize for another binary.
; RUN: llvm-lto2 run -save-temps -o %t2 %t.bc -r %t.bc,fptr,plx \ ; RUN: llvm-lto2 run -save-temps -o %t2 %t.bc -r %t.bc,fptr,plx \
; RUN: -r %t.bc,main,plx -r %t.bc,_ZL3foov,l ; RUN: -r %t.bc,main,plx -r %t.bc,_ZL3foov,l
; RUN: llvm-dis < %t2.1.4.opt.bc | FileCheck %s --check-prefix=OPT ; RUN: llvm-dis < %t2.1.4.opt.bc | FileCheck %s --check-prefix=OPT
; RUN: llvm-lto2 run -save-temps -o %t2 %t.bc -r %t.bc,fptr,plx \ ; RUN: llvm-lto2 run -save-temps -o %t2 %t.bc -r %t.bc,fptr,plx \
; RUN: -r %t.bc,main,plx -r %t.bc,_ZL3foov,l -compute-dead=false ; RUN: -r %t.bc,main,plx -r %t.bc,_ZL3foov,l -compute-dead=false
; RUN: llvm-dis < %t2.1.4.opt.bc | FileCheck %s --check-prefix=OPT-NODEAD ; RUN: llvm-dis < %t2.1.4.opt.bc | FileCheck %s --check-prefix=OPT-NODEAD
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
@fptr = local_unnamed_addr global void ()* null, align 8 @fptr = local_unnamed_addr global void ()* null, align 8
define void @_ZL3foov() #1 { define void @_ZL3foov() #1 {
entry: entry:
ret void ret void
} }
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/unreachable_bb.ll

; RUN: llvm-profdata merge %S/Inputs/unreachable_bb.proftext -o %t.profdata ; RUN: llvm-profdata merge %S/Inputs/unreachable_bb.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE ; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @foo() { define void @foo() {
entry: entry:
call void @bar() call void @bar()
unreachable unreachable
return: return:
ret void ret void
Show All 10 Lines

llvm/test/tools/llvm-lto2/X86/pipeline.ll

Show All 9 Lines
; RUN: -r %t1.bc,patatino,px -opt-pipeline loweratomic \ ; RUN: -r %t1.bc,patatino,px -opt-pipeline loweratomic \
; RUN: -aa-pipeline basic-aa ; RUN: -aa-pipeline basic-aa
; RUN: llvm-dis < %t.o.0.4.opt.bc | FileCheck %s --check-prefix=CUSTOM ; RUN: llvm-dis < %t.o.0.4.opt.bc | FileCheck %s --check-prefix=CUSTOM
; Try the new pass manager LTO default pipeline (make sure the option ; Try the new pass manager LTO default pipeline (make sure the option
; is accepted). ; is accepted).
; RUN: llvm-lto2 run %t1.bc -o %t.o -use-new-pm -r %t1.bc,patatino,px ; RUN: llvm-lto2 run %t1.bc -o %t.o -use-new-pm -r %t1.bc,patatino,px
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @patatino() { define void @patatino() {
fence seq_cst fence seq_cst
ret void ret void
} }
; CUSTOM: define void @patatino() { ; CUSTOM: define void @patatino() {
Show All 16 Lines

llvm/test/tools/llvm-lto2/X86/stats-file-option.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: llvm-as < %s > %t1.bc ; RUN: llvm-as < %s > %t1.bc
; Try to save statistics to file. ; Try to save statistics to file.
; RUN: llvm-lto2 run %t1.bc -o %t.o -r %t1.bc,patatino,px -stats-file=%t2.stats ; RUN: llvm-lto2 run %t1.bc -o %t.o -r %t1.bc,patatino,px -stats-file=%t2.stats
; RUN: FileCheck --input-file=%t2.stats %s ; RUN: FileCheck --input-file=%t2.stats %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 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" target triple = "x86_64-unknown-linux-gnu"
define void @patatino() { define void @patatino() {
fence seq_cst fence seq_cst
ret void ret void
} }
; CHECK: { ; CHECK: {
; CHECK: "asm-printer.EmittedInsts": ; CHECK: "asm-printer.EmittedInsts":
; CHECK: } ; CHECK: }
; Try to save statistics to an invalid file. ; Try to save statistics to an invalid file.
; RUN: not llvm-lto2 run %t1.bc -o %t.o -r %t1.bc,patatino,px \ ; RUN: not llvm-lto2 run %t1.bc -o %t.o -r %t1.bc,patatino,px \
; RUN: -stats-file=%t2/foo.stats 2>&1 | FileCheck --check-prefix=ERROR %s ; RUN: -stats-file=%t2/foo.stats 2>&1 | FileCheck --check-prefix=ERROR %s
; ERROR: LTO::run failed: {{[Nn]}}o such file or directory ; ERROR: LTO::run failed: {{[Nn]}}o such file or directory