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
771–772

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
771–772

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
119–120

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/
3 lines
14 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
llvm/
lib/
Target/
X86/
3 lines
test/
Analysis/
BasicAA/
2 lines
2 lines
GlobalsModRef/
2 lines
2 lines
LoopAccessAnalysis/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
ScalarEvolution/
2 lines
2 lines
2 lines
Bitcode/
2 lines
2 lines
Inputs/
2 lines
2 lines
2 lines
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
Linker/
Inputs/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Other/
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
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
Verifier/
2 lines
2 lines
2 lines
2 lines
tools/
llvm-lto2/
X86/
2 lines
2 lines

Diff 210607

clang/lib/Basic/Targets/OSTargets.h

Show First 20 Lines • Show All 762 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-p253:32:32-p254:32:32-p255:64:64-"
"i64:64-n8:16:32-S128");
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…
} else if (Triple.getArch() == llvm::Triple::x86_64) { } else if (Triple.getArch() == llvm::Triple::x86_64) {
this->resetDataLayout("e-m:e-p:32:32-i64:64-n8:16:32:64-S128"); this->resetDataLayout("e-m:e-p:32:32-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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/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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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/lib/Target/X86/X86TargetMachine.cpp

Show First 20 Lines • Show All 110 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 += "-p253:32:32-p254:32:32-p255: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/Analysis/BasicAA/bug.23626.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-darwin13.4.0" target triple = "x86_64-apple-darwin13.4.0"
; CHECK-LABEL: compute1 ; CHECK-LABEL: compute1
; CHECK: MayAlias: i32* %arrayidx8, i32* %out ; CHECK: MayAlias: i32* %arrayidx8, i32* %out
; CHECK: MayAlias: i32* %arrayidx11, i32* %out ; CHECK: MayAlias: i32* %arrayidx11, i32* %out
; CHECK: MayAlias: i32* %arrayidx11, i32* %arrayidx8 ; CHECK: MayAlias: i32* %arrayidx11, i32* %arrayidx8
; CHECK: MayAlias: i32* %arrayidx14, i32* %out ; CHECK: MayAlias: i32* %arrayidx14, i32* %out
; CHECK: MayAlias: i32* %arrayidx14, i32* %arrayidx8 ; CHECK: MayAlias: i32* %arrayidx14, i32* %arrayidx8
Show All 21 Lines

llvm/test/Analysis/BasicAA/pr31761.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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"
%struct.blam = type { i32, i32 } %struct.blam = type { i32, i32 }
; CHECK-DAG: MayAlias: i32* %tmp, i32* %tmp3 ; CHECK-DAG: MayAlias: i32* %tmp, i32* %tmp3
define i1 @ham(%struct.blam* %arg) { define i1 @ham(%struct.blam* %arg) {
%isNull = icmp eq %struct.blam* %arg, null %isNull = icmp eq %struct.blam* %arg, null
%tmp = getelementptr %struct.blam, %struct.blam* %arg, i64 0, i32 0 %tmp = getelementptr %struct.blam, %struct.blam* %arg, i64 0, i32 0
%tmp2 = getelementptr %struct.blam, %struct.blam* %arg, i64 0, i32 1 %tmp2 = getelementptr %struct.blam, %struct.blam* %arg, i64 0, i32 1
%select = select i1 %isNull, i32* null, i32* %tmp2 %select = select i1 %isNull, i32* null, i32* %tmp2
%tmp3 = getelementptr i32, i32* %select, i32 -1 %tmp3 = getelementptr i32, i32* %select, i32 -1
ret i1 true ret i1 true
} }

llvm/test/Analysis/GlobalsModRef/memset-escape.ll

; RUN: opt < %s -O1 -S | FileCheck %s ; RUN: opt < %s -O1 -S | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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"
@a = internal global [3 x i32] zeroinitializer, align 4 @a = internal global [3 x i32] zeroinitializer, align 4
@b = common global i32 0, align 4 @b = common global i32 0, align 4
; The important thing we're checking for here is the reload of (some element of) ; The important thing we're checking for here is the reload of (some element of)
; @a after the memset. ; @a after the memset.
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

llvm/test/Analysis/GlobalsModRef/no-escape.ll

; RUN: opt < %s -basicaa -globals-aa -S -licm | FileCheck %s ; RUN: opt < %s -basicaa -globals-aa -S -licm | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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"
@b = common global i32 0, align 4 @b = common global i32 0, align 4
@c = internal global i32 0, align 4 @c = internal global i32 0, align 4
@d = common global i32 0, align 4 @d = common global i32 0, align 4
@e = common global i32* null, align 4 @e = common global i32* null, align 4
define void @foo(i32* %P) noinline { define void @foo(i32* %P) noinline {
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

llvm/test/Analysis/LoopAccessAnalysis/backward-dep-different-types.ll

; RUN: opt -loop-accesses -analyze < %s | FileCheck %s ; RUN: opt -loop-accesses -analyze < %s | FileCheck %s
; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s 2>&1 | FileCheck %s
; In this loop just because we access A through different types (int, float) ; In this loop just because we access A through different types (int, float)
; we still have a dependence cycle: ; we still have a dependence cycle:
; ;
; for (i = 0; i < n; i++) { ; for (i = 0; i < n; i++) {
; A_float = (float *) A; ; A_float = (float *) A;
; A_float[i + 1] = A[i] * B[i]; ; A_float[i + 1] = A[i] * B[i];
; } ; }
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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: Report: unsafe dependent memory operations in loop ; CHECK: Report: unsafe dependent memory operations in loop
; CHECK-NOT: Memory dependences are safe ; CHECK-NOT: Memory dependences are safe
@B = common global i32* null, align 8 @B = common global i32* null, align 8
@A = common global i32* null, align 8 @A = common global i32* null, align 8
Show All 30 Lines

llvm/test/Analysis/LoopAccessAnalysis/forward-loop-carried.ll

; RUN: opt -loop-accesses -analyze < %s | FileCheck %s ; RUN: opt -loop-accesses -analyze < %s | FileCheck %s
; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s 2>&1 | FileCheck %s
; for (unsigned i = 0; i < 100; i++) { ; for (unsigned i = 0; i < 100; i++) {
; A[i+8] = B[i] + 2; ; A[i+8] = B[i] + 2;
; C[i] = A[i] * 2; ; C[i] = A[i] * 2;
; } ; }
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @f(i32* %A, i32* %B, i32* %C, i64 %N) { define void @f(i32* %A, i32* %B, i32* %C, i64 %N) {
; CHECK: Dependences: ; CHECK: Dependences:
; CHECK-NEXT: Forward: ; CHECK-NEXT: Forward:
; CHECK-NEXT: store i32 %a_p1, i32* %Aidx_ahead, align 4 -> ; CHECK-NEXT: store i32 %a_p1, i32* %Aidx_ahead, align 4 ->
; CHECK-NEXT: %a = load i32, i32* %Aidx, align 4 ; CHECK-NEXT: %a = load i32, i32* %Aidx, align 4
Show All 28 Lines

llvm/test/Analysis/LoopAccessAnalysis/forward-loop-independent.ll

Show All 13 Lines
; MemoryDepChecker analysis for accesses of A. ; MemoryDepChecker analysis for accesses of A.
; ;
; for (unsigned i = 0; i < 100; i++) { ; for (unsigned i = 0; i < 100; i++) {
; A[i + 1] = B[i] + 1; // *** ; A[i + 1] = B[i] + 1; // ***
; A[i] = B[i] + 2; ; A[i] = B[i] + 2;
; C[i] = A[i] * 2; ; C[i] = A[i] * 2;
; } ; }
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @f(i32* noalias %A, i32* noalias %B, i32* noalias %C, i64 %N) { define void @f(i32* noalias %A, i32* noalias %B, i32* noalias %C, i64 %N) {
; CHECK: Dependences: ; CHECK: Dependences:
; CHECK-NEXT: Forward: ; CHECK-NEXT: Forward:
; CHECK-NEXT: store i32 %b_p1, i32* %Aidx, align 4 -> ; CHECK-NEXT: store i32 %b_p1, i32* %Aidx, align 4 ->
; CHECK-NEXT: %a = load i32, i32* %Aidx, align 4 ; CHECK-NEXT: %a = load i32, i32* %Aidx, align 4
; CHECK: ForwardButPreventsForwarding: ; CHECK: ForwardButPreventsForwarding:
Show All 35 Lines

llvm/test/Analysis/LoopAccessAnalysis/memcheck-for-loop-invariant.ll

; RUN: opt -loop-accesses -analyze < %s | FileCheck %s ; RUN: opt -loop-accesses -analyze < %s | FileCheck %s
; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s 2>&1 | FileCheck %s
; Handle memchecks involving loop-invariant addresses: ; Handle memchecks involving loop-invariant addresses:
; ;
; extern int *A, *b; ; extern int *A, *b;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; A[i] = b; ; A[i] = b;
; } ; }
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
; CHECK: Memory dependences are safe with run-time checks ; CHECK: Memory dependences are safe with run-time checks
; CHECK: Run-time memory checks: ; CHECK: Run-time memory checks:
; CHECK-NEXT: Check 0: ; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group ({{.*}}): ; CHECK-NEXT: Comparing group ({{.*}}):
; CHECK-NEXT: %arrayidxA = getelementptr inbounds i32, i32* %a, i64 %ind ; CHECK-NEXT: %arrayidxA = getelementptr inbounds i32, i32* %a, i64 %ind
; CHECK-NEXT: Against group ({{.*}}): ; CHECK-NEXT: Against group ({{.*}}):
; CHECK-NEXT: i32* %b ; CHECK-NEXT: i32* %b
Show All 20 Lines

llvm/test/Analysis/LoopAccessAnalysis/non-wrapping-pointer.ll

; RUN: opt -basicaa -loop-accesses -analyze < %s | FileCheck %s ; RUN: opt -basicaa -loop-accesses -analyze < %s | FileCheck %s
; RUN: opt -passes='require<aa>,require<scalar-evolution>,require<aa>,loop(print-access-info)' -aa-pipeline='basic-aa' -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -passes='require<aa>,require<scalar-evolution>,require<aa>,loop(print-access-info)' -aa-pipeline='basic-aa' -disable-output < %s 2>&1 | FileCheck %s
; For this loop: ; For this loop:
; for (int i = 0; i < n; i++) ; for (int i = 0; i < n; i++)
; A[2 * i] = A[2 * i] + B[i]; ; A[2 * i] = A[2 * i] + B[i];
; ;
; , SCEV is unable to prove that A[2 * i] does not overflow. However, ; , SCEV is unable to prove that A[2 * i] does not overflow. However,
; analyzing the IR helps us to conclude it and in turn allow dependence ; analyzing the IR helps us to conclude it and in turn allow dependence
; analysis. ; analysis.
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
; CHECK: Memory dependences are safe{{$}} ; CHECK: Memory dependences are safe{{$}}
define void @f(i16* noalias %a, define void @f(i16* noalias %a,
i16* noalias %b, i64 %N) { i16* noalias %b, i64 %N) {
entry: entry:
br label %for.body br label %for.body
Show All 22 Lines

llvm/test/Analysis/LoopAccessAnalysis/nullptr.ll

; RUN: opt -loop-accesses -analyze %s | FileCheck %s ; RUN: opt -loop-accesses -analyze %s | FileCheck %s
; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s 2>&1 | FileCheck %s
; Test that the loop accesses are proven safe in this case. ; Test that the loop accesses are proven safe in this case.
; The analyzer uses to be confused by the "diamond" because GetUnderlyingObjects ; The analyzer uses to be confused by the "diamond" because GetUnderlyingObjects
; is saying that the two pointers can both points to null. The loop analyzer ; is saying that the two pointers can both points to null. The loop analyzer
; needs to ignore null in the results returned by GetUnderlyingObjects. ; needs to ignore null in the results returned by GetUnderlyingObjects.
; CHECK: Memory dependences are safe with run-time checks ; CHECK: Memory dependences are safe with run-time checks
; ModuleID = 'bugpoint-reduced-simplified.bc' ; ModuleID = 'bugpoint-reduced-simplified.bc'
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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"
; Function Attrs: ssp uwtable ; Function Attrs: ssp uwtable
define void @foo(i1 %cond, i32* %ptr1, i32* %ptr2) { define void @foo(i1 %cond, i32* %ptr1, i32* %ptr2) {
br i1 %cond, label %.preheader, label %diamond br i1 %cond, label %.preheader, label %diamond
diamond: ; preds = %.noexc.i.i diamond: ; preds = %.noexc.i.i
br label %.preheader br label %.preheader
Show All 18 Lines

llvm/test/Analysis/LoopAccessAnalysis/pointer-with-unknown-bounds.ll

; RUN: opt -loop-accesses -analyze < %s | FileCheck %s ; RUN: opt -loop-accesses -analyze < %s | FileCheck %s
; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s 2>&1 | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
; We shouldn't quit the analysis if we encounter a pointer without known ; We shouldn't quit the analysis if we encounter a pointer without known
; bounds *unless* we actually need to emit a memcheck for it. (We only ; bounds *unless* we actually need to emit a memcheck for it. (We only
; compute bounds for SCEVAddRecs so A[i*i] is deemed not having known bounds.) ; compute bounds for SCEVAddRecs so A[i*i] is deemed not having known bounds.)
; ;
; for (i = 0; i < 20; ++i) ; for (i = 0; i < 20; ++i)
; A[i*i] *= 2; ; A[i*i] *= 2;
Show All 31 Lines

llvm/test/Analysis/LoopAccessAnalysis/resort-to-memchecks-only.ll

; RUN: opt -loop-accesses -analyze < %s | FileCheck %s ; RUN: opt -loop-accesses -analyze < %s | FileCheck %s
; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s 2>&1 | FileCheck %s
; We give up analyzing the dependences in this loop due to non-constant ; We give up analyzing the dependences in this loop due to non-constant
; distance between A[i+offset] and A[i] and add memchecks to prove ; distance between A[i+offset] and A[i] and add memchecks to prove
; independence. Make sure that no dependences are reported in ; independence. Make sure that no dependences are reported in
; this case. ; this case.
; ;
; for (i = 0; i < n; i++) ; for (i = 0; i < n; i++)
; A[i + offset] = A[i] * B[i] * C[i]; ; A[i + offset] = A[i] * B[i] * C[i];
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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: Memory dependences are safe with run-time checks ; CHECK: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences: ; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks: ; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: 0: ; CHECK-NEXT: 0:
; CHECK-NEXT: Comparing group ; CHECK-NEXT: Comparing group
; CHECK-NEXT: %arrayidxA2 = getelementptr inbounds i16, i16* %a, i64 %idx ; CHECK-NEXT: %arrayidxA2 = getelementptr inbounds i16, i16* %a, i64 %idx
Show All 40 Lines

llvm/test/Analysis/LoopAccessAnalysis/safe-no-checks.ll

; RUN: opt -basicaa -loop-accesses -analyze < %s | FileCheck %s ; RUN: opt -basicaa -loop-accesses -analyze < %s | FileCheck %s
; RUN: opt -passes='require<aa>,require<scalar-evolution>,require<aa>,loop(print-access-info)' -aa-pipeline='basic-aa' -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -passes='require<aa>,require<scalar-evolution>,require<aa>,loop(print-access-info)' -aa-pipeline='basic-aa' -disable-output < %s 2>&1 | FileCheck %s
; If the arrays don't alias this loop is safe with no memchecks: ; If the arrays don't alias this loop is safe with no memchecks:
; for (i = 0; i < n; i++) ; for (i = 0; i < n; i++)
; A[i] = A[i+1] * B[i] * C[i]; ; A[i] = A[i+1] * B[i] * C[i];
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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 the loop-carried forward anti-dep between the load of A[i+1] and the ; Check the loop-carried forward anti-dep between the load of A[i+1] and the
; store of A[i]; ; store of A[i];
; CHECK: Memory dependences are safe{{$}} ; CHECK: Memory dependences are safe{{$}}
; CHECK-NEXT: Dependences: ; CHECK-NEXT: Dependences:
; CHECK-NEXT: Forward: ; CHECK-NEXT: Forward:
Show All 36 Lines

llvm/test/Analysis/LoopAccessAnalysis/safe-with-dep-distance.ll

; RUN: opt -loop-accesses -analyze < %s | FileCheck %s ; RUN: opt -loop-accesses -analyze < %s | FileCheck %s
; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s 2>&1 | FileCheck %s
; Analyze this loop: ; Analyze this loop:
; for (i = 0; i < n; i++) ; for (i = 0; i < n; i++)
; A[i + 4] = A[i] * 2; ; A[i + 4] = A[i] * 2;
; CHECK: Memory dependences are safe with a maximum dependence distance of 8 bytes ; CHECK: Memory dependences are safe with a maximum dependence distance of 8 bytes
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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"
@A = common global i16* null, align 8 @A = common global i16* null, align 8
define void @f() { define void @f() {
entry: entry:
%a = load i16*, i16** @A, align 8 %a = load i16*, i16** @A, align 8
br label %for.body br label %for.body
Show All 20 Lines

llvm/test/Analysis/LoopAccessAnalysis/underlying-objects-1.ll

Show All 9 Lines
; ;
; make sure, we look through the PHI to conclude that store_ptr and load_ptr ; make sure, we look through the PHI to conclude that store_ptr and load_ptr
; both have A as their underlying object. The dependence is safe for ; both have A as their underlying object. The dependence is safe for
; vectorization requiring no memchecks. ; vectorization requiring no memchecks.
; ;
; Otherwise we would try to prove independence with a memcheck that is going ; Otherwise we would try to prove independence with a memcheck that is going
; to always fail. ; to always fail.
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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: Memory dependences are safe{{$}} ; CHECK: Memory dependences are safe{{$}}
define void @f(i8* noalias %A, i64 %width) { define void @f(i8* noalias %A, i64 %width) {
for.body.preheader: for.body.preheader:
%A_ahead = getelementptr inbounds i8, i8* %A, i64 2 %A_ahead = getelementptr inbounds i8, i8* %A, i64 2
br label %for.body br label %for.body
Show All 22 Lines

llvm/test/Analysis/LoopAccessAnalysis/underlying-objects-2.ll

Show All 28 Lines
; If it did we would try to dependence-analyze Curr and Prev and the analysis ; If it did we would try to dependence-analyze Curr and Prev and the analysis
; would fail with non-constant distance. ; would fail with non-constant distance.
; ;
; To illustrate one of the negative consequences of this, if the loop has a ; To illustrate one of the negative consequences of this, if the loop has a
; backward dependence we won't detect this but instead fully fall back on ; backward dependence we won't detect this but instead fully fall back on
; memchecks (that is what LAA does after encountering a case of non-constant ; memchecks (that is what LAA does after encountering a case of non-constant
; distance). ; distance).
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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: for_j.body: ; CHECK: for_j.body:
; CHECK-NEXT: Report: unsafe dependent memory operations in loop ; CHECK-NEXT: Report: unsafe dependent memory operations in loop
; CHECK-NEXT: Dependences: ; CHECK-NEXT: Dependences:
; CHECK-NEXT: Backward: ; CHECK-NEXT: Backward:
; CHECK-NEXT: %loadB = load i8, i8* %gepB, align 1 -> ; CHECK-NEXT: %loadB = load i8, i8* %gepB, align 1 ->
; CHECK-NEXT: store i8 2, i8* %gepB_plus_one, align 1 ; CHECK-NEXT: store i8 2, i8* %gepB_plus_one, align 1
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

llvm/test/Analysis/LoopAccessAnalysis/unsafe-and-rt-checks-convergent.ll

; RUN: opt -loop-accesses -analyze < %s | FileCheck %s ; RUN: opt -loop-accesses -analyze < %s | FileCheck %s
; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s 2>&1 | FileCheck %s
; Analyze this loop: ; Analyze this loop:
; for (i = 0; i < n; i++) ; for (i = 0; i < n; i++)
; A[i + 1] = A[i] * B[i] * C[i]; ; A[i + 1] = A[i] * B[i] * C[i];
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
; CHECK: for.body: ; CHECK: for.body:
; CHECK: Has convergent operation in loop ; CHECK: Has convergent operation in loop
; CHECK: Report: cannot add control dependency to convergent operation ; CHECK: Report: cannot add control dependency to convergent operation
; CHECK-NEXT: Dependences: ; CHECK-NEXT: Dependences:
; CHECK-NEXT: Backward: ; CHECK-NEXT: Backward:
; CHECK-NEXT: %loadA = load i16, i16* %arrayidxA, align 2 -> ; CHECK-NEXT: %loadA = load i16, i16* %arrayidxA, align 2 ->
; CHECK-NEXT: store i16 %mul1, i16* %arrayidxA_plus_2, align 2 ; CHECK-NEXT: store i16 %mul1, i16* %arrayidxA_plus_2, align 2
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/test/Analysis/LoopAccessAnalysis/unsafe-and-rt-checks.ll

; RUN: opt -loop-accesses -analyze < %s | FileCheck %s ; RUN: opt -loop-accesses -analyze < %s | FileCheck %s
; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s 2>&1 | FileCheck %s
; Analyze this loop: ; Analyze this loop:
; for (i = 0; i < n; i++) ; for (i = 0; i < n; i++)
; A[i + 1] = A[i] * B[i] * C[i]; ; A[i + 1] = A[i] * B[i] * C[i];
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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: Report: unsafe dependent memory operations in loop ; CHECK: Report: unsafe dependent memory operations in loop
; CHECK-NEXT: Dependences: ; CHECK-NEXT: Dependences:
; CHECK-NEXT: Backward: ; CHECK-NEXT: Backward:
; CHECK-NEXT: %loadA = load i16, i16* %arrayidxA, align 2 -> ; CHECK-NEXT: %loadA = load i16, i16* %arrayidxA, align 2 ->
; CHECK-NEXT: store i16 %mul1, i16* %arrayidxA_plus_2, align 2 ; CHECK-NEXT: store i16 %mul1, i16* %arrayidxA_plus_2, align 2
; CHECK: Run-time memory checks: ; CHECK: Run-time memory checks:
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

llvm/test/Analysis/LoopAccessAnalysis/wrapping-pointer-versioning.ll

; RUN: opt -basicaa -loop-accesses -analyze < %s | FileCheck %s -check-prefix=LAA ; RUN: opt -basicaa -loop-accesses -analyze < %s | FileCheck %s -check-prefix=LAA
; RUN: opt -passes='require<aa>,require<scalar-evolution>,require<aa>,loop(print-access-info)' -aa-pipeline='basic-aa' -disable-output < %s 2>&1 | FileCheck %s --check-prefix=LAA ; RUN: opt -passes='require<aa>,require<scalar-evolution>,require<aa>,loop(print-access-info)' -aa-pipeline='basic-aa' -disable-output < %s 2>&1 | FileCheck %s --check-prefix=LAA
; RUN: opt -loop-versioning -S < %s | FileCheck %s -check-prefix=LV ; RUN: opt -loop-versioning -S < %s | FileCheck %s -check-prefix=LV
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
; For this loop: ; For this loop:
; unsigned index = 0; ; unsigned index = 0;
; for (int i = 0; i < n; i++) { ; for (int i = 0; i < n; i++) {
; A[2 * index] = A[2 * index] + B[i]; ; A[2 * index] = A[2 * index] + B[i];
; index++; ; index++;
; } ; }
; ;
▲ Show 20 Lines • Show All 416 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/ZeroStep.ll

; RUN: opt -analyze -scalar-evolution < %s -o - -S | FileCheck %s ; RUN: opt -analyze -scalar-evolution < %s -o - -S | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
; Test that SCEV is capable of figuring out value of 'IV' that actually does not change. ; Test that SCEV is capable of figuring out value of 'IV' that actually does not change.
; CHECK: Classifying expressions for: @foo ; CHECK: Classifying expressions for: @foo
; CHECK: %iv.i = phi i64 ; CHECK: %iv.i = phi i64
; CHECK: -5 U: [-5,-4) S: [-5,-4) Exits: -5 LoopDispositions: { %loop: Invariant } ; CHECK: -5 U: [-5,-4) S: [-5,-4) Exits: -5 LoopDispositions: { %loop: Invariant }
define void @foo() { define void @foo() {
entry: entry:
br label %loop br label %loop
loop: loop:
%iv.i = phi i64 [ -5, %entry ], [ %iv.next.i, %loop ] %iv.i = phi i64 [ -5, %entry ], [ %iv.next.i, %loop ]
%iv.next.i = add nsw i64 %iv.i, 0 %iv.next.i = add nsw i64 %iv.i, 0
br label %loop br label %loop
} }

llvm/test/Analysis/ScalarEvolution/expander-replace-congruent-ivs.ll

; RUN: opt -S -indvars < %s | FileCheck %s ; RUN: opt -S -indvars < %s | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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"
; SCEVExpander would try to RAUW %val_2 with %c.lcssa, breaking "def ; SCEVExpander would try to RAUW %val_2 with %c.lcssa, breaking "def
; dominates uses". ; dominates uses".
define void @pr27232(i32 %val) { define void @pr27232(i32 %val) {
; CHECK-LABEL: @pr27232( ; CHECK-LABEL: @pr27232(
entry: entry:
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/pr24757.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s
; CHECK: Loop %bb1: backedge-taken count is ((2 * %a.promoted) /u 2) ; CHECK: Loop %bb1: backedge-taken count is ((2 * %a.promoted) /u 2)
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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"
@a = global i8 -127, align 1 @a = global i8 -127, align 1
@b = common global i32 0, align 4 @b = common global i32 0, align 4
declare void @use(i32) declare void @use(i32)
define i32 @main() { define i32 @main() {
Show All 22 Lines

llvm/test/Bitcode/DIGlobalVariableExpression2.ll

; RUN: llvm-dis -o - %s.bc | FileCheck %s ; RUN: llvm-dis -o - %s.bc | FileCheck %s
; CHECK: @g = common global i32 0, align 4, !dbg ![[G:[0-9]+]] ; CHECK: @g = common global i32 0, align 4, !dbg ![[G:[0-9]+]]
; CHECK-DAG: ![[G]] = distinct !DIGlobalVariableExpression(var: ![[GVAR:[0-9]+]], expr: !DIExpression()) ; CHECK-DAG: ![[G]] = distinct !DIGlobalVariableExpression(var: ![[GVAR:[0-9]+]], expr: !DIExpression())
; CHECK-DAG: distinct !DICompileUnit({{.*}}, globals: ![[GLOBS:[0-9]+]] ; CHECK-DAG: distinct !DICompileUnit({{.*}}, globals: ![[GLOBS:[0-9]+]]
; CHECK-DAG: ![[GLOBS]] = !{![[GEXPR:[0-9]+]]} ; CHECK-DAG: ![[GLOBS]] = !{![[GEXPR:[0-9]+]]}
; CHECK-DAG: ![[GEXPR]] = distinct !DIGlobalVariableExpression(var: ![[GVAR]], expr: !DIExpression()) ; CHECK-DAG: ![[GEXPR]] = distinct !DIGlobalVariableExpression(var: ![[GVAR]], expr: !DIExpression())
; CHECK-DAG: ![[GVAR]] = !DIGlobalVariable(name: "g", ; CHECK-DAG: ![[GVAR]] = !DIGlobalVariable(name: "g",
; Test the bitcode upgrade for DIGlobalVariable -> DIGlobalVariableExpression. ; Test the bitcode upgrade for DIGlobalVariable -> DIGlobalVariableExpression.
; ModuleID = 'a.c' ; ModuleID = 'a.c'
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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"
@g = common global i32 0, align 4 @g = common global i32 0, align 4
!llvm.dbg.cu = !{!0} !llvm.dbg.cu = !{!0}
!llvm.module.flags = !{!6, !7, !8} !llvm.module.flags = !{!6, !7, !8}
!llvm.ident = !{!9} !llvm.ident = !{!9}
Show All 10 Lines

llvm/test/Bitcode/DINamespace.ll

; RUN: llvm-dis %s.bc -o - | FileCheck %s ; RUN: llvm-dis %s.bc -o - | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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"
@_ZN1N1iE = global i32 0, align 4, !dbg !0 @_ZN1N1iE = global i32 0, align 4, !dbg !0
!llvm.dbg.cu = !{!4} !llvm.dbg.cu = !{!4}
!llvm.module.flags = !{!7, !8, !9} !llvm.module.flags = !{!7, !8, !9}
!llvm.ident = !{!10} !llvm.ident = !{!10}
Show All 13 Lines

llvm/test/Bitcode/Inputs/module_hash.ll

; Needs a function for the combined index to be populated ; Needs a function for the combined index to be populated
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @bar() { define void @bar() {
ret void ret void
} }

llvm/test/Bitcode/drop-debug-info.3.5.ll

; RUN: llvm-dis < %s.bc -o %t.ll 2>&1 | FileCheck -check-prefix=WARN %s ; RUN: llvm-dis < %s.bc -o %t.ll 2>&1 | FileCheck -check-prefix=WARN %s
; RUN: FileCheck -input-file=%t.ll %s ; RUN: FileCheck -input-file=%t.ll %s
; The bitcode paired with this test was generated by passing this file to ; The bitcode paired with this test was generated by passing this file to
; llvm-dis-3.5. This tests that llvm-dis warns correctly when reading old ; llvm-dis-3.5. This tests that llvm-dis warns correctly when reading old
; bitcode. ; bitcode.
; CHECK-NOT: !llvm.dbg.cu ; CHECK-NOT: !llvm.dbg.cu
; CHECK-NOT: !dbg ; CHECK-NOT: !dbg
; WARN: warning: ignoring debug info with an invalid version (1) ; WARN: warning: ignoring debug info with an invalid version (1)
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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"
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define i32 @main() #0 { define i32 @main() #0 {
entry: entry:
%retval = alloca i32, align 4 %retval = alloca i32, align 4
store i32 0, i32* %retval store i32 0, i32* %retval
ret i32 0, !dbg !12 ret i32 0, !dbg !12
Show All 21 Lines

llvm/test/Bitcode/module_hash.ll

Show All 22 Lines
; First capture the value of the hash for the two modules. ; First capture the value of the hash for the two modules.
; COMBINED: <HASH op0=[[HASH1_1:[0-9]*]] op1=[[HASH1_2:[0-9]*]] op2=[[HASH1_3:[0-9]*]] op3=[[HASH1_4:[0-9]*]] op4=[[HASH1_5:[0-9]*]]/> ; COMBINED: <HASH op0=[[HASH1_1:[0-9]*]] op1=[[HASH1_2:[0-9]*]] op2=[[HASH1_3:[0-9]*]] op3=[[HASH1_4:[0-9]*]] op4=[[HASH1_5:[0-9]*]]/>
; COMBINED: <HASH op0=[[HASH2_1:[0-9]*]] op1=[[HASH2_2:[0-9]*]] op2=[[HASH2_3:[0-9]*]] op3=[[HASH2_4:[0-9]*]] op4=[[HASH2_5:[0-9]*]]/> ; COMBINED: <HASH op0=[[HASH2_1:[0-9]*]] op1=[[HASH2_2:[0-9]*]] op2=[[HASH2_3:[0-9]*]] op3=[[HASH2_4:[0-9]*]] op4=[[HASH2_5:[0-9]*]]/>
; Validate against the value extracted from the combined index ; Validate against the value extracted from the combined index
; COMBINED-DAG: <HASH abbrevid={{[0-9]*}} op0=[[HASH1_1]] op1=[[HASH1_2]] op2=[[HASH1_3]] op3=[[HASH1_4]] op4=[[HASH1_5]]/> ; COMBINED-DAG: <HASH abbrevid={{[0-9]*}} op0=[[HASH1_1]] op1=[[HASH1_2]] op2=[[HASH1_3]] op3=[[HASH1_4]] op4=[[HASH1_5]]/>
; COMBINED-DAG: <HASH abbrevid={{[0-9]*}} op0=[[HASH2_1]] op1=[[HASH2_2]] op2=[[HASH2_3]] op3=[[HASH2_4]] op4=[[HASH2_5]]/> ; COMBINED-DAG: <HASH abbrevid={{[0-9]*}} op0=[[HASH2_1]] op1=[[HASH2_2]] op2=[[HASH2_3]] op3=[[HASH2_4]] op4=[[HASH2_5]]/>
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
; Need a function for the combined index to be populated. ; Need a function for the combined index to be populated.
define void @foo() { define void @foo() {
ret void ret void
} }

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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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/type-mapping-bug2.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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/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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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/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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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/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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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/Linker/Inputs/odr-lambda-2.ll

; ModuleID = '/tmp/odr-lambda-2.ii' ; ModuleID = '/tmp/odr-lambda-2.ii'
; generated from: ; generated from:
; clang++ -x c++ -std=c++14 -fPIC -flto -g -fno-exceptions -fno-rtti ; clang++ -x c++ -std=c++14 -fPIC -flto -g -fno-exceptions -fno-rtti
; class Error {}; ; class Error {};
; template <typename HandlerTs> ; template <typename HandlerTs>
; void handleAllErrors( HandlerTs Handlers) {} ; void handleAllErrors( HandlerTs Handlers) {}
; inline void consumeError(Error Err) { ; inline void consumeError(Error Err) {
; handleAllErrors( []() {}); ; handleAllErrors( []() {});
; } ; }
; int main(int argc, char **argv) { ; int main(int argc, char **argv) {
; consumeError(Error()); ; consumeError(Error());
; } ; }
source_filename = "/tmp/odr-lambda-2.ii" source_filename = "/tmp/odr-lambda-2.ii"
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.13.0" target triple = "x86_64-apple-macosx10.13.0"
%class.Error = type { i8 } %class.Error = type { i8 }
%class.anon = type { i8 } %class.anon = type { i8 }
; Function Attrs: noinline norecurse nounwind optnone ssp uwtable ; Function Attrs: noinline norecurse nounwind optnone ssp uwtable
define i32 @main(i32 %argc, i8** %argv) #0 !dbg !8 { define i32 @main(i32 %argc, i8** %argv) #0 !dbg !8 {
entry: entry:
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

llvm/test/Linker/alias-3.ll

; RUN: llvm-link %s -S -o - | FileCheck %s ; RUN: llvm-link %s -S -o - | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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"
; CHECK-DAG: @A = internal constant i8 1 ; CHECK-DAG: @A = internal constant i8 1
; CHECK-DAG: @B = alias i8, i8* @A ; CHECK-DAG: @B = alias i8, i8* @A
; CHECK-DAG: @C = global [2 x i8*] [i8* @A, i8* @B] ; CHECK-DAG: @C = global [2 x i8*] [i8* @A, i8* @B]
@A = internal constant i8 1 @A = internal constant i8 1
@B = alias i8, i8* @A @B = alias i8, i8* @A
@C = global [2 x i8*] [i8* @A, i8* @B] @C = global [2 x i8*] [i8* @A, i8* @B]

llvm/test/Linker/debug-info-global-var.ll

; RUN: llvm-link -S %s %S/debug-info-version-a.ll | FileCheck %s ; RUN: llvm-link -S %s %S/debug-info-version-a.ll | FileCheck %s
source_filename = "debug-info-global-var.c" source_filename = "debug-info-global-var.c"
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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"
; CHECK: @g = global i32 0, align 4, !dbg ![[G:[0-9]+]]{{$}} ; CHECK: @g = global i32 0, align 4, !dbg ![[G:[0-9]+]]{{$}}
@g = global i32 0, align 4, !dbg !0 @g = global i32 0, align 4, !dbg !0
!llvm.dbg.cu = !{!1} !llvm.dbg.cu = !{!1}
!llvm.module.flags = !{!6, !7, !8} !llvm.module.flags = !{!6, !7, !8}
!llvm.ident = !{!9} !llvm.ident = !{!9}
Show All 14 Lines

llvm/test/Linker/null_mapping_constant.ll

; RUN: llvm-link %s -S -o - | FileCheck %s ; RUN: llvm-link %s -S -o - | FileCheck %s
; Check that the constant is not linked and the metadata is correctly referencing a nullptr ; Check that the constant is not linked and the metadata is correctly referencing a nullptr
; CHECK: !0 = !{!"foo", null, i64 16} ; CHECK: !0 = !{!"foo", null, i64 16}
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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"
@foo = external unnamed_addr constant { [4 x i8*], [32 x i8] }, align 32 @foo = external unnamed_addr constant { [4 x i8*], [32 x i8] }, align 32
!llvm.bitsets = !{!0} !llvm.bitsets = !{!0}
!0 = !{!"foo", [4 x i8*]* getelementptr inbounds ({ [4 x i8*], [32 x i8] }, { [4 x i8*], [32 x i8] }* @foo, i32 0, i32 0), i64 16} !0 = !{!"foo", [4 x i8*]* getelementptr inbounds ({ [4 x i8*], [32 x i8] }, { [4 x i8*], [32 x i8] }* @foo, i32 0, i32 0), i64 16}

llvm/test/Linker/odr-lambda-1.ll

Show All 18 Lines
; handleAllErrors( []() {}); ; handleAllErrors( []() {});
; } ; }
; void ArchiveMemberHeader() ; void ArchiveMemberHeader()
; { ; {
; consumeError(Error()); ; consumeError(Error());
; } ; }
source_filename = "/tmp/odr-lambda-1.ii" source_filename = "/tmp/odr-lambda-1.ii"
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.13.0" target triple = "x86_64-apple-macosx10.13.0"
%class.Error = type { i8 } %class.Error = type { i8 }
%class.anon = type { i8 } %class.anon = type { i8 }
; Function Attrs: noinline nounwind optnone ssp uwtable ; Function Attrs: noinline nounwind optnone ssp uwtable
define void @_Z19ArchiveMemberHeaderv() #0 !dbg !8 { define void @_Z19ArchiveMemberHeaderv() #0 !dbg !8 {
entry: entry:
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

llvm/test/Linker/type-unique-simple2-b.ll

; RUN: true ; RUN: true
; This file belongs to type-unique-simple2-a.ll. ; This file belongs to type-unique-simple2-a.ll.
; ;
; $ cat b.cpp ; $ cat b.cpp
; #include "ab.h" ; #include "ab.h"
; void A::setFoo() {} ; void A::setFoo() {}
; const ; const
; foo_t A::getFoo() { return 1; } ; foo_t A::getFoo() { return 1; }
; ModuleID = 'b.cpp' ; ModuleID = 'b.cpp'
; target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" ; target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
; target triple = "x86_64-apple-macosx10.9.0" ; target triple = "x86_64-apple-macosx10.9.0"
%class.A = type { i32 (...)** } %class.A = type { i32 (...)** }
@_ZTV1A = unnamed_addr constant [4 x i8*] [i8* null, i8* bitcast ({ i8*, i8* }* @_ZTI1A to i8*), i8* bitcast (void (%class.A*)* @_ZN1A6setFooEv to i8*), i8* bitcast (i32 (%class.A*)* @_ZN1A6getFooEv to i8*)] @_ZTV1A = unnamed_addr constant [4 x i8*] [i8* null, i8* bitcast ({ i8*, i8* }* @_ZTI1A to i8*), i8* bitcast (void (%class.A*)* @_ZN1A6setFooEv to i8*), i8* bitcast (i32 (%class.A*)* @_ZN1A6getFooEv to i8*)]
@_ZTVN10__cxxabiv117__class_type_infoE = external global i8* @_ZTVN10__cxxabiv117__class_type_infoE = external global i8*
@_ZTS1A = constant [3 x i8] c"1A\00" @_ZTS1A = constant [3 x i8] c"1A\00"
@_ZTI1A = unnamed_addr constant { i8*, i8* } { i8* bitcast (i8** getelementptr inbounds (i8*, i8** @_ZTVN10__cxxabiv117__class_type_infoE, i64 2) to i8*), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZTS1A, i32 0, i32 0) } @_ZTI1A = unnamed_addr constant { i8*, i8* } { i8* bitcast (i8** getelementptr inbounds (i8*, i8** @_ZTVN10__cxxabiv117__class_type_infoE, i64 2) to i8*), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZTS1A, i32 0, i32 0) }
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

llvm/test/Other/optimization-remarks-lazy-bfi.ll

Show All 24 Lines
; ;
; 1 void forced (char *A, char *B, char *C, int N) { ; 1 void forced (char *A, char *B, char *C, int N) {
; 2 #pragma clang loop distribute(enable) ; 2 #pragma clang loop distribute(enable)
; 3 for(int i = 0; i < N; i++) { ; 3 for(int i = 0; i < N; i++) {
; 4 A[i] = B[i] * C[i]; ; 4 A[i] = B[i] * C[i];
; 5 } ; 5 }
; 6 } ; 6 }
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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 @forced(i8* %A, i8* %B, i8* %C, i32 %N) !dbg !7 !prof !22 { define void @forced(i8* %A, i8* %B, i8* %C, i32 %N) !dbg !7 !prof !22 {
entry: entry:
%cmp12 = icmp sgt i32 %N, 0, !dbg !9 %cmp12 = icmp sgt i32 %N, 0, !dbg !9
br i1 %cmp12, label %ph, label %for.cond.cleanup, !dbg !10, !prof !23 br i1 %cmp12, label %ph, label %for.cond.cleanup, !dbg !10, !prof !23
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

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

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
@globalfuncAlias = alias void (...), bitcast (void ()* @globalfunc to void (...)*) @globalfuncAlias = alias void (...), bitcast (void ()* @globalfunc to void (...)*)
@globalfuncWeakAlias = weak alias void (...), bitcast (void ()* @globalfunc to void (...)*) @globalfuncWeakAlias = weak alias void (...), bitcast (void ()* @globalfunc to void (...)*)
@globalfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @globalfunc to void (...)*) @globalfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @globalfunc to void (...)*)
@globalfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @globalfunc to void (...)*) @globalfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @globalfunc to void (...)*)
@globalfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @globalfunc to void (...)*) @globalfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @globalfunc to void (...)*)
define hidden void @globalfunc() { define hidden void @globalfunc() {
entry: entry:
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 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-p253:32:32-p254:32:32-p255:64: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/alias_resolution.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
@globalfuncAlias = alias void (...), bitcast (void ()* @globalfunc to void (...)*) @globalfuncAlias = alias void (...), bitcast (void ()* @globalfunc to void (...)*)
@globalfuncWeakAlias = weak alias void (...), bitcast (void ()* @globalfunc to void (...)*) @globalfuncWeakAlias = weak alias void (...), bitcast (void ()* @globalfunc to void (...)*)
@globalfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @globalfunc to void (...)*) @globalfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @globalfunc to void (...)*)
@globalfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @globalfunc to void (...)*) @globalfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @globalfunc to void (...)*)
@globalfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @globalfunc to void (...)*) @globalfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @globalfunc to void (...)*)
define void @globalfunc() { define void @globalfunc() {
entry: entry:
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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/diagnostic-handler-remarks.ll

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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/distributed_import.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
@G = internal global i32 7 @G = internal global i32 7
define i32 @g() { define i32 @g() {
entry: entry:
%0 = load i32, i32* @G %0 = load i32, i32* @G
ret i32 %0 ret i32 %0
} }
@analias = alias void (...), bitcast (void ()* @aliasee to void (...)*) @analias = alias void (...), bitcast (void ()* @aliasee to void (...)*)
define void @aliasee() { define void @aliasee() {
entry: entry:
ret void ret void
} }

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

target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @g() { define void @g() {
entry: entry:
ret void ret void
} }
@analias = alias void (...), bitcast (void ()* @aliasee to void (...)*) @analias = alias void (...), bitcast (void ()* @aliasee to void (...)*)
define void @aliasee() { define void @aliasee() {
entry: entry:
ret void ret void
} }

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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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/emit_imports.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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/section.ll

; An internal global variable that can't be renamed because it has a section ; An internal global variable that can't be renamed because it has a section
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
@var_with_section = internal global i32 0, section "some_section" @var_with_section = internal global i32 0, section "some_section"
; @reference_gv_with_section() can't be imported ; @reference_gv_with_section() can't be imported
define i32 @reference_gv_with_section() { define i32 @reference_gv_with_section() {
%res = load i32, i32* @var_with_section %res = load i32, i32* @var_with_section
ret i32 %res ret i32 %res
} }
; canary ; canary
define void @foo() { define void @foo() {
ret void ret void
} }

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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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_import.ll

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
; IMPORT-DAG: define available_externally void @weakfuncWeakODRAlias() ; IMPORT-DAG: define available_externally void @weakfuncWeakODRAlias()
; IMPORT-DAG: define available_externally void @weakfuncLinkonceODRAlias() ; IMPORT-DAG: define available_externally void @weakfuncLinkonceODRAlias()
; IMPORT-DAG: define available_externally void @linkonceODRfuncAlias() ; IMPORT-DAG: define available_externally void @linkonceODRfuncAlias()
; IMPORT-DAG: declare void @linkonceODRfuncWeakAlias() ; IMPORT-DAG: declare void @linkonceODRfuncWeakAlias()
; IMPORT-DAG: define available_externally void @linkonceODRfuncWeakODRAlias() ; IMPORT-DAG: define available_externally void @linkonceODRfuncWeakODRAlias()
; IMPORT-DAG: declare void @linkonceODRfuncLinkonceAlias() ; IMPORT-DAG: declare void @linkonceODRfuncLinkonceAlias()
; IMPORT-DAG: define available_externally void @linkonceODRfuncLinkonceODRAlias() ; IMPORT-DAG: define available_externally void @linkonceODRfuncLinkonceODRAlias()
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
define i32 @main() #0 { define i32 @main() #0 {
entry: entry:
call void @globalfuncAlias() call void @globalfuncAlias()
call void @globalfuncWeakAlias() call void @globalfuncWeakAlias()
call void @globalfuncLinkonceAlias() call void @globalfuncLinkonceAlias()
call void @globalfuncWeakODRAlias() call void @globalfuncWeakODRAlias()
call void @globalfuncLinkonceODRAlias() call void @globalfuncLinkonceODRAlias()
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 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-p253:32:32-p254:32:32-p255:64: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/alias_resolution.ll

Show All 37 Lines
; PROMOTE_MOD1: @weakfuncLinkonceAlias = weak alias void (...), bitcast (void ()* @weakfunc{{.*}} to void (...)*) ; PROMOTE_MOD1: @weakfuncLinkonceAlias = weak alias void (...), bitcast (void ()* @weakfunc{{.*}} to void (...)*)
; PROMOTE_MOD2: @weakfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @weakfunc{{.*}} to void (...)*) ; PROMOTE_MOD2: @weakfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @weakfunc{{.*}} to void (...)*)
; FIXME: The "resolution" should turn one of these to linkonce_odr ; FIXME: The "resolution" should turn one of these to linkonce_odr
; PROMOTE_MOD1: @weakfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @weakfunc.mod1 to void (...)*) ; PROMOTE_MOD1: @weakfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @weakfunc.mod1 to void (...)*)
; PROMOTE_MOD2: @weakfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @weakfunc to void (...)*) ; PROMOTE_MOD2: @weakfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @weakfunc to void (...)*)
; PROMOTE_MOD1: @weakfuncLinkonceODRAlias = weak_odr alias void (...), bitcast (void ()* @weakfunc.mod1 to void (...)*) ; PROMOTE_MOD1: @weakfuncLinkonceODRAlias = weak_odr alias void (...), bitcast (void ()* @weakfunc.mod1 to void (...)*)
; PROMOTE_MOD2: @weakfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @weakfunc to void (...)*) ; PROMOTE_MOD2: @weakfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @weakfunc to void (...)*)
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
@linkonceODRfuncAlias = alias void (...), bitcast (void ()* @linkonceODRfunc.mod1 to void (...)*) @linkonceODRfuncAlias = alias void (...), bitcast (void ()* @linkonceODRfunc.mod1 to void (...)*)
@linkonceODRfuncWeakAlias = weak alias void (...), bitcast (void ()* @linkonceODRfunc.mod1 to void (...)*) @linkonceODRfuncWeakAlias = weak alias void (...), bitcast (void ()* @linkonceODRfunc.mod1 to void (...)*)
@linkonceODRfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @linkonceODRfunc.mod1 to void (...)*) @linkonceODRfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @linkonceODRfunc.mod1 to void (...)*)
@linkonceODRfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @linkonceODRfunc.mod1 to void (...)*) @linkonceODRfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @linkonceODRfunc.mod1 to void (...)*)
@linkonceODRfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @linkonceODRfunc.mod1 to void (...)*) @linkonceODRfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @linkonceODRfunc.mod1 to void (...)*)
define linkonce_odr void @linkonceODRfunc.mod1() { define linkonce_odr void @linkonceODRfunc.mod1() {
entry: entry:
Show All 33 Lines

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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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 76 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-p253:32:32-p254:32:32-p255: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 57 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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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/distributed_indexes.ll

Show All 40 Lines
; BACKEND2-NEXT: </GLOBALVAL_SUMMARY_BLOCK ; BACKEND2-NEXT: </GLOBALVAL_SUMMARY_BLOCK
; Make sure that when the alias is imported as a copy of the aliasee, but the ; Make sure that when the alias is imported as a copy of the aliasee, but the
; aliasee is not being imported by itself, that we can still print the summary. ; aliasee is not being imported by itself, that we can still print the summary.
; The aliasee should be "null". ; The aliasee should be "null".
; RUN: llvm-dis %t1.bc.thinlto.bc -o - | FileCheck %s --check-prefix=DIS ; RUN: llvm-dis %t1.bc.thinlto.bc -o - | FileCheck %s --check-prefix=DIS
; DIS: aliasee: null ; DIS: aliasee: null
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
declare void @g(...) declare void @g(...)
declare void @analias(...) declare void @analias(...)
define void @f() { define void @f() {
entry: entry:
call void (...) @g() call void (...) @g()
call void (...) @analias() call void (...) @analias()
ret void ret void
} }

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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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 All 35 Lines
; INTERNALIZE-OPTION-DISABLE: define weak void @linkonce_func() ; INTERNALIZE-OPTION-DISABLE: define weak void @linkonce_func()
; INTERNALIZE2: define dso_local void @foo ; INTERNALIZE2: define dso_local void @foo
; INTERNALIZE2: define internal void @bar ; INTERNALIZE2: define internal void @bar
; INTERNALIZE2: define internal void @linkonce_func() ; INTERNALIZE2: define internal void @linkonce_func()
; 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()
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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()
ret void ret void
} }
define linkonce void @linkonce_func() { define linkonce void @linkonce_func() {
ret void ret void
} }

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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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/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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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/prefix_replace.ll

; Check that changing the output path via prefix-replace works ; Check that changing the output path via prefix-replace works
; Use of '/' in paths created here make this unsuitable for Windows. ; Use of '/' in paths created here make this unsuitable for Windows.
; RUN: mkdir -p %t/oldpath ; RUN: mkdir -p %t/oldpath
; RUN: opt -module-summary %s -o %t/oldpath/prefix_replace.o ; RUN: opt -module-summary %s -o %t/oldpath/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/prefix_replace.o.thinlto.bc ; RUN: rm -f %t/newpath/prefix_replace.o.thinlto.bc
; RUN: llvm-lto -thinlto-action=thinlink -o %t.index.bc %t/oldpath/prefix_replace.o ; RUN: llvm-lto -thinlto-action=thinlink -o %t.index.bc %t/oldpath/prefix_replace.o
; RUN: llvm-lto -thinlto-action=distributedindexes -thinlto-prefix-replace="%t/oldpath/;%t/newpath/" -thinlto-index %t.index.bc %t/oldpath/prefix_replace.o ; RUN: llvm-lto -thinlto-action=distributedindexes -thinlto-prefix-replace="%t/oldpath/;%t/newpath/" -thinlto-index %t.index.bc %t/oldpath/prefix_replace.o
; RUN: ls %t/newpath/prefix_replace.o.thinlto.bc ; RUN: ls %t/newpath/prefix_replace.o.thinlto.bc
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
define void @f() { define void @f() {
entry: entry:
ret void ret void
} }

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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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/section.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/section.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/section.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 don't promote 'var_with_section' ; Check that we don't promote 'var_with_section'
; RUN: llvm-lto -thinlto-action=promote %t2.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=PROMOTE ; RUN: llvm-lto -thinlto-action=promote %t2.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=PROMOTE
; PROMOTE: @var_with_section = internal global i32 0, section "some_section" ; PROMOTE: @var_with_section = internal global i32 0, section "some_section"
; RUN: llvm-lto -thinlto-action=import %t.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=IMPORT ; RUN: llvm-lto -thinlto-action=import %t.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=IMPORT
; Check that section prevent import of @reference_gv_with_section. ; Check that section prevent import of @reference_gv_with_section.
; IMPORT: declare void @reference_gv_with_section() ; IMPORT: declare void @reference_gv_with_section()
; Canary to check that importing is correctly set up. ; Canary to check that importing is correctly set up.
; IMPORT: define available_externally void @foo() ; IMPORT: define available_externally void @foo()
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
define i32 @main() { define i32 @main() {
call void @reference_gv_with_section() call void @reference_gv_with_section()
call void @foo() call void @foo()
ret i32 42 ret i32 42
} }
declare void @reference_gv_with_section() declare void @reference_gv_with_section()
declare void @foo() declare void @foo()

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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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/weak_resolution_single.ll

; RUN: opt -module-summary %s -o %t.bc ; RUN: opt -module-summary %s -o %t.bc
; RUN: llvm-lto -thinlto-action=thinlink -o %t2.bc %t.bc ; RUN: llvm-lto -thinlto-action=thinlink -o %t2.bc %t.bc
; RUN: llvm-lto -thinlto-action=internalize %t.bc -thinlto-index=%t2.bc -exported-symbol=foo -o - | llvm-dis -o - | FileCheck %s ; RUN: llvm-lto -thinlto-action=internalize %t.bc -thinlto-index=%t2.bc -exported-symbol=foo -o - | llvm-dis -o - | FileCheck %s
; CHECK: define weak_odr void @foo() ; CHECK: define weak_odr void @foo()
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
define linkonce_odr void @foo() { define linkonce_odr void @foo() {
ret void ret void
} }

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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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/Verifier/DILocation-parents.ll

; RUN: llvm-as -disable-output %s -o - 2>&1 | FileCheck %s ; RUN: llvm-as -disable-output %s -o - 2>&1 | FileCheck %s
source_filename = "t.c" source_filename = "t.c"
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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 void @f() !dbg !4 { define void @f() !dbg !4 {
entry: entry:
; CHECK: scope points into the type hierarchy ; CHECK: scope points into the type hierarchy
; CHECK: DILocation ; CHECK: DILocation
ret void, !dbg !7 ret void, !dbg !7
} }
Show All 25 Lines

llvm/test/Verifier/DILocation-scope.ll

; RUN: llvm-as -disable-output %s -o - 2>&1 | FileCheck %s ; RUN: llvm-as -disable-output %s -o - 2>&1 | FileCheck %s
source_filename = "t.c" source_filename = "t.c"
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.13.0" target triple = "x86_64-apple-macosx10.13.0"
define void @f() !dbg !4 { define void @f() !dbg !4 {
entry: entry:
; CHECK: scope must be a DILocalScope ; CHECK: scope must be a DILocalScope
; CHECK: DILocation ; CHECK: DILocation
ret void, !dbg !6 ret void, !dbg !6
} }
Show All 13 Lines

llvm/test/Verifier/callsite-dbgloc.ll

; RUN: llvm-as %s -o %t 2>&1 | FileCheck %s ; RUN: llvm-as %s -o %t 2>&1 | FileCheck %s
; Created and then edited from ; Created and then edited from
; extern void i(); ; extern void i();
; void h() { i(); } ; void h() { i(); }
; void g() { h(); } ; void g() { h(); }
; void f() { g(); } ; void f() { g(); }
; ;
; Compiling this with inlining runs into the ; Compiling this with inlining runs into the
; "!dbg attachment points at wrong subprogram for function" ; "!dbg attachment points at wrong subprogram for function"
; assertion. ; assertion.
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx" target triple = "x86_64-apple-macosx"
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
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 20 Lines • Show All 44 Lines • Show Last 20 Lines

llvm/test/Verifier/fnarg-nodebug.ll

; RUN: llvm-as < %s -o %t ; RUN: llvm-as < %s -o %t
; RUN: llvm-dis < %t -o - | FileCheck %s ; RUN: llvm-dis < %t -o - | FileCheck %s
; Created at -O1 from: ; Created at -O1 from:
; int sink(int); ; int sink(int);
; __attribute__((always_inline)) int f(int i) { return sink(i); } ; __attribute__((always_inline)) int f(int i) { return sink(i); }
; __attribute__((always_inline)) int g(int j) { return sink(j); } ; __attribute__((always_inline)) int g(int j) { return sink(j); }
; __attribute__((nodebug)) int nodebug(int k) { return f(k)+g(k); } ; __attribute__((nodebug)) int nodebug(int k) { return f(k)+g(k); }
source_filename = "t.c" source_filename = "t.c"
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p253:32:32-p254:32:32-p255: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"
declare i32 @sink(i32) local_unnamed_addr declare i32 @sink(i32) local_unnamed_addr
define i32 @nodebug(i32 %k) local_unnamed_addr #2 { define i32 @nodebug(i32 %k) local_unnamed_addr #2 {
entry: entry:
; This should not set off the FnArg Verifier. The two variables are in differrent scopes. ; This should not set off the FnArg Verifier. The two variables are in differrent scopes.
tail call void @llvm.dbg.value(metadata i32 %k, i64 0, metadata !12, metadata !13) #4, !dbg !14 tail call void @llvm.dbg.value(metadata i32 %k, i64 0, metadata !12, metadata !13) #4, !dbg !14
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 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-p253:32:32-p254:32:32-p255:64: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-p253:32:32-p254:32:32-p255:64: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