This is an archive of the discontinued LLVM Phabricator instance.

Differential D78862

[IR] Convert null-pointer-is-valid into an enum attribute
ClosedPublic

Authored by nikic on Apr 25 2020, 7:00 AM.

Details

Reviewers
jdoerfert
manojgupta
efriedma
sstefan1
Commits
rGf89f7da999f3: [IR] Convert null-pointer-is-valid into an enum attribute
Summary

The "null-pointer-is-valid" attribute needs to be checked by many pointer-related combines. To make the check more efficient, convert it from a string into an enum attribute.

While D78859 already makes the check for the attribute cheaper, this is another 0.4% improvement.

Diff Detail

Event Timeline

nikic created this revision.Apr 25 2020, 7:00 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 25 2020, 7:00 AM
Herald added subscribers: llvm-commits, dexonsmith, steven_wu, hiraditya. · View Herald Transcript
xbolva00 added a subscriber: xbolva00.Apr 25 2020, 7:55 AM

Just wondering if this allso enables

attribute((null_pointer_is_valid)) in Clang?

Harbormaster failed remote builds in B54677: Diff 260092!Apr 25 2020, 7:56 AM
nikic added a comment.Apr 25 2020, 8:10 AM

@xbolva00 This should not change any front-end behavior. I believe in clang this is controlled by -fno-delete-null-pointer-checks.

nikic updated this revision to Diff 260105.Apr 25 2020, 8:35 AM

Update tests

Herald added a reviewer: jdoerfert. · View Herald TranscriptApr 25 2020, 8:35 AM
Herald added a reviewer: sstefan1. · View Herald Transcript
Herald added a reviewer: ftynse. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: cfe-commits, Kayjukh, frgossen and 15 others. · View Herald Transcript
arsenm added a subscriber: arsenm.Apr 25 2020, 9:20 AM

FWIW I think this attribute should be replaced with a data layout property, so this would eventually be removed

arsenm added a comment.Apr 25 2020, 9:21 AM
In D78862#2003684, @arsenm wrote:

FWIW I think this attribute should be replaced with a data layout property, so this would eventually be removed

Also would be address space specific

Harbormaster failed remote builds in B54685: Diff 260105!Apr 25 2020, 9:32 AM
nikic added a comment.Apr 25 2020, 10:15 AM
In D78862#2003684, @arsenm wrote:

FWIW I think this attribute should be replaced with a data layout property, so this would eventually be removed

Is this change planned more for the near term or the long term? I'm not really familiar with ongoing addrspace related work.

nikic added a comment.Apr 26 2020, 1:04 AM

@arsenm If the null-pointer-is-valid attribute is moved into the data layout, I'm wondering how Clang's -fno-delete-null-pointer-checks option would work or what it would be replaced with. In Rust it is possible to define a custom target, which also defines a custom data-layout, though I think that also needs to be compatible with the base target. I couldn't find any information on how to use a custom data layout in Clang. As such, I suspect that to preserve existing functionality we'd need support both for specifying this per-addrspace in the DL and as a function attribute.

ftynse resigned from this revision.Apr 27 2020, 4:40 AM
nikic edited reviewers, added: manojgupta, efriedma; removed: sstefan1, ftynse.Apr 28 2020, 11:53 AM
Herald added a reviewer: sstefan1. · View Herald TranscriptApr 28 2020, 11:53 AM
nikic edited the summary of this revision. (Show Details)Apr 28 2020, 11:54 AM
manojgupta added a comment.Apr 28 2020, 2:14 PM

@nikic Thanks for the work.

In D78862#2003684, @arsenm wrote:

FWIW I think this attribute should be replaced with a data layout property, so this would eventually be removed

@arsenm Is there any work planned on moving to data layout? Moving to data layout may affect cross TU inlining e.g. LTO where 1 TU is compiled with -fno-delete-null-pointer-checks and other TU is not. There might be other potential impact that we might not know yet.

jdoerfert added a comment.Apr 30 2020, 6:04 AM

I think this is an improvement over the status quo and it looks fine to me.

@arsenm I agree that we should tie this to the data layout (or at least should try) but I guess there are open questions to answer and code to write.
I propose to accept this and work on the DL patch after. WDYT?

In D78862#2008831, @manojgupta wrote:

@nikic Thanks for the work.

In D78862#2003684, @arsenm wrote:

FWIW I think this attribute should be replaced with a data layout property, so this would eventually be removed

@arsenm Is there any work planned on moving to data layout? Moving to data layout may affect cross TU inlining e.g. LTO where 1 TU is compiled with -fno-delete-null-pointer-checks and other TU is not. There might be other potential impact that we might not know yet.

If we link modules with mismatching data layouts we can/should deal with this by utilizing more address spaces. That is, change the address space in one module to a fresh one to keep the properties alive. There need to be rules for this and infrastructure but something similar might be needed for heterogeneous IR modules soon. Different story though. We can also combine the attribute and the data layout if necessary, though I'm not a fan.

llvm/lib/Bitcode/Reader/BitcodeReader.cpp
1304–1305

I guess this change can go in as NFC simplification right away.

nikic updated this revision to Diff 261279.Apr 30 2020, 10:22 AM
nikic marked an inline comment as done.

Rebase over committed NFC changes.

Harbormaster failed remote builds in B55332: Diff 261279!Apr 30 2020, 11:15 AM
nikic updated this revision to Diff 261375.Apr 30 2020, 3:11 PM

Fix rebase mistake in test

Harbormaster failed remote builds in B55381: Diff 261375!Apr 30 2020, 4:07 PM
nikic added a comment.May 8 2020, 1:15 AM

Ping

Herald added a subscriber: stephenneuendorffer. · View Herald TranscriptMay 8 2020, 1:15 AM
arsenm added a comment.May 8 2020, 10:48 AM
In D78862#2012560, @jdoerfert wrote:

I think this is an improvement over the status quo and it looks fine to me.

@arsenm I agree that we should tie this to the data layout (or at least should try) but I guess there are open questions to answer and code to write.
I propose to accept this and work on the DL patch after. WDYT?

Seems ok, but it's still burning an enum value which I guess isn't super important. With the datalayout property, we might really want the inverse attribute

In D78862#2008831, @manojgupta wrote:

@nikic Thanks for the work.

In D78862#2003684, @arsenm wrote:

FWIW I think this attribute should be replaced with a data layout property, so this would eventually be removed

@arsenm Is there any work planned on moving to data layout? Moving to data layout may affect cross TU inlining e.g. LTO where 1 TU is compiled with -fno-delete-null-pointer-checks and other TU is not. There might be other potential impact that we might not know yet.

If we link modules with mismatching data layouts we can/should deal with this by utilizing more address spaces. That is, change the address space in one module to a fresh one to keep the properties alive. There need to be rules for this and infrastructure but something similar might be needed for heterogeneous IR modules soon. Different story though. We can also combine the attribute and the data layout if necessary, though I'm not a fan.

This sounds really problematic and would require way more knowledge of target address spaces. I don't think this will work

jdoerfert accepted this revision.May 14 2020, 9:21 PM
In D78862#2027254, @arsenm wrote:
In D78862#2012560, @jdoerfert wrote:

I think this is an improvement over the status quo and it looks fine to me.

@arsenm I agree that we should tie this to the data layout (or at least should try) but I guess there are open questions to answer and code to write.
I propose to accept this and work on the DL patch after. WDYT?

Seems ok, but it's still burning an enum value which I guess isn't super important. With the datalayout property, we might really want the inverse attribute

Given that we lifted the limits on enum attributes I don't think this cost is high. Since we do not have a scheduled alternative, I think this should land.

This revision is now accepted and ready to land.May 14 2020, 9:21 PM
Herald added subscribers: jurahul, kuter. · View Herald TranscriptMay 14 2020, 9:21 PM
Closed by commit rGf89f7da999f3: [IR] Convert null-pointer-is-valid into an enum attribute (authored by nikic). · Explain WhyMay 15 2020, 10:52 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
clang/
lib/
CodeGen/
2 lines
test/
CodeGen/
4 lines
llvm/
docs/
4 lines
include/
llvm/
Bitcode/
1 line
IR/
3 lines
5 lines
lib/
AsmParser/
1 line
2 lines
1 line
Bitcode/
Reader/
4 lines
Writer/
2 lines
IR/
6 lines
14 lines
4 lines
1 line
Transforms/
Utils/
1 line
test/
Analysis/
MemorySSA/
2 lines
ValueTracking/
2 lines
Bitcode/
7 lines
Transforms/
Attributor/
IPConstantProp/
2 lines
2 lines
2 lines
2 lines
4 lines
8 lines
CorrelatedValuePropagation/
2 lines
FunctionAttrs/
2 lines
2 lines
GVN/
PRE/
2 lines
GlobalOpt/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
IPConstantProp/
2 lines
Inline/
20 lines
InstCombine/
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
InstSimplify/
2 lines
LoopIdiom/
2 lines
LoopVersioning/
2 lines
SimplifyCFG/
2 lines
2 lines
2 lines
2 lines
2 lines
Util/
2 lines
mlir/
test/
Target/
4 lines

Diff 264285

clang/lib/CodeGen/CGCall.cpp

Show First 20 Lines • Show All 1,738 Lines • ▼ Show 20 Lines case CodeGenOptions::FramePointerKind::All:
break; break;
} }
FuncAttrs.addAttribute("frame-pointer", FpKind); FuncAttrs.addAttribute("frame-pointer", FpKind);
FuncAttrs.addAttribute("less-precise-fpmad", FuncAttrs.addAttribute("less-precise-fpmad",
llvm::toStringRef(CodeGenOpts.LessPreciseFPMAD)); llvm::toStringRef(CodeGenOpts.LessPreciseFPMAD));
if (CodeGenOpts.NullPointerIsValid) if (CodeGenOpts.NullPointerIsValid)
FuncAttrs.addAttribute("null-pointer-is-valid", "true"); FuncAttrs.addAttribute(llvm::Attribute::NullPointerIsValid);
if (CodeGenOpts.FPDenormalMode != llvm::DenormalMode::getIEEE()) if (CodeGenOpts.FPDenormalMode != llvm::DenormalMode::getIEEE())
FuncAttrs.addAttribute("denormal-fp-math", FuncAttrs.addAttribute("denormal-fp-math",
CodeGenOpts.FPDenormalMode.str()); CodeGenOpts.FPDenormalMode.str());
if (CodeGenOpts.FP32DenormalMode != CodeGenOpts.FPDenormalMode) { if (CodeGenOpts.FP32DenormalMode != CodeGenOpts.FPDenormalMode) {
FuncAttrs.addAttribute( FuncAttrs.addAttribute(
"denormal-fp-math-f32", "denormal-fp-math-f32",
CodeGenOpts.FP32DenormalMode.str()); CodeGenOpts.FP32DenormalMode.str());
▲ Show 20 Lines • Show All 3,334 Lines • Show Last 20 Lines

clang/test/CodeGen/delete-null-pointer-checks.c

Show All 10 Lines
// NULL-POINTER-VALID: load i32, i32* %[[SEL:.*]] // NULL-POINTER-VALID: load i32, i32* %[[SEL:.*]]
int *Q = P; int *Q = P;
if (P) { if (P) {
Q = P + 2; Q = P + 2;
} }
return *Q; return *Q;
} }
// NULL-POINTER-INVALID-NOT: attributes #0 = {{.*}} "null-pointer-is-valid"="true" // NULL-POINTER-INVALID-NOT: attributes #0 = {{.*}} null_pointer_is_valid
// NULL-POINTER-VALID: attributes #0 = {{.*}} "null-pointer-is-valid"="true" // NULL-POINTER-VALID: attributes #0 = {{.*}} null_pointer_is_valid

llvm/docs/LangRef.rst

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,574 Lines • ▼ Show 20 Lines``nosync``
the behavior is undefined. the behavior is undefined.
``nounwind`` ``nounwind``
This function attribute indicates that the function never raises an This function attribute indicates that the function never raises an
exception. If the function does raise an exception, its runtime exception. If the function does raise an exception, its runtime
behavior is undefined. However, functions marked nounwind may still behavior is undefined. However, functions marked nounwind may still
trap or generate asynchronous exceptions. Exception handling schemes trap or generate asynchronous exceptions. Exception handling schemes
that are recognized by LLVM to handle asynchronous exceptions, such that are recognized by LLVM to handle asynchronous exceptions, such
as SEH, will still provide their implementation defined semantics. as SEH, will still provide their implementation defined semantics.
``"null-pointer-is-valid"`` ``null_pointer_is_valid``
If ``"null-pointer-is-valid"`` is set to ``"true"``, then ``null`` address If ``null_pointer_is_valid`` is set, then the ``null`` address
in address-space 0 is considered to be a valid address for memory loads and in address-space 0 is considered to be a valid address for memory loads and
stores. Any analysis or optimization should not treat dereferencing a stores. Any analysis or optimization should not treat dereferencing a
pointer to ``null`` as undefined behavior in this function. pointer to ``null`` as undefined behavior in this function.
Note: Comparing address of a global variable to ``null`` may still Note: Comparing address of a global variable to ``null`` may still
evaluate to false because of a limitation in querying this attribute inside evaluate to false because of a limitation in querying this attribute inside
constant expressions. constant expressions.
``optforfuzzing`` ``optforfuzzing``
This attribute indicates that this function should be optimized This attribute indicates that this function should be optimized
▲ Show 20 Lines • Show All 18,251 Lines • Show Last 20 Lines

llvm/include/llvm/Bitcode/LLVMBitCodes.h

Show First 20 Lines • Show All 631 Lines • ▼ Show 20 Linesenum AttributeKindCodes {
ATTR_KIND_SPECULATIVE_LOAD_HARDENING = 59, ATTR_KIND_SPECULATIVE_LOAD_HARDENING = 59,
ATTR_KIND_IMMARG = 60, ATTR_KIND_IMMARG = 60,
ATTR_KIND_WILLRETURN = 61, ATTR_KIND_WILLRETURN = 61,
ATTR_KIND_NOFREE = 62, ATTR_KIND_NOFREE = 62,
ATTR_KIND_NOSYNC = 63, ATTR_KIND_NOSYNC = 63,
ATTR_KIND_SANITIZE_MEMTAG = 64, ATTR_KIND_SANITIZE_MEMTAG = 64,
ATTR_KIND_PREALLOCATED = 65, ATTR_KIND_PREALLOCATED = 65,
ATTR_KIND_NO_MERGE = 66, ATTR_KIND_NO_MERGE = 66,
ATTR_KIND_NULL_POINTER_IS_VALID = 67,
}; };
enum ComdatSelectionKindCodes { enum ComdatSelectionKindCodes {
COMDAT_SELECTION_KIND_ANY = 1, COMDAT_SELECTION_KIND_ANY = 1,
COMDAT_SELECTION_KIND_EXACT_MATCH = 2, COMDAT_SELECTION_KIND_EXACT_MATCH = 2,
COMDAT_SELECTION_KIND_LARGEST = 3, COMDAT_SELECTION_KIND_LARGEST = 3,
COMDAT_SELECTION_KIND_NO_DUPLICATES = 4, COMDAT_SELECTION_KIND_NO_DUPLICATES = 4,
COMDAT_SELECTION_KIND_SAME_SIZE = 5, COMDAT_SELECTION_KIND_SAME_SIZE = 5,
Show All 14 Lines

llvm/include/llvm/IR/Attributes.td

Show First 20 Lines • Show All 121 Lines • ▼ Show 20 Lines
def NoSync : EnumAttr<"nosync">; def NoSync : EnumAttr<"nosync">;
/// Disable Indirect Branch Tracking. /// Disable Indirect Branch Tracking.
def NoCfCheck : EnumAttr<"nocf_check">; def NoCfCheck : EnumAttr<"nocf_check">;
/// Function doesn't unwind stack. /// Function doesn't unwind stack.
def NoUnwind : EnumAttr<"nounwind">; def NoUnwind : EnumAttr<"nounwind">;
/// Null pointer in address space zero is valid.
def NullPointerIsValid : EnumAttr<"null_pointer_is_valid">;
/// Select optimizations for best fuzzing signal. /// Select optimizations for best fuzzing signal.
def OptForFuzzing : EnumAttr<"optforfuzzing">; def OptForFuzzing : EnumAttr<"optforfuzzing">;
/// opt_size. /// opt_size.
def OptimizeForSize : EnumAttr<"optsize">; def OptimizeForSize : EnumAttr<"optsize">;
/// Function must not be optimized. /// Function must not be optimized.
def OptimizeNone : EnumAttr<"optnone">; def OptimizeNone : EnumAttr<"optnone">;
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

llvm/include/llvm/IR/AutoUpgrade.h

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Linesnamespace llvm {
/// Upgrade the loop attachment metadata node. /// Upgrade the loop attachment metadata node.
MDNode *upgradeInstructionLoopAttachment(MDNode &N); MDNode *upgradeInstructionLoopAttachment(MDNode &N);
/// Upgrade the datalayout string by adding a section for address space /// Upgrade the datalayout string by adding a section for address space
/// pointers. /// pointers.
std::string UpgradeDataLayoutString(StringRef DL, StringRef Triple); std::string UpgradeDataLayoutString(StringRef DL, StringRef Triple);
/// Upgrade function attributes "no-frame-pointer-elim" and /// Upgrade attributes that changed format or kind.
/// "no-frame-pointer-elim-non-leaf" to "frame-pointer". void UpgradeAttributes(AttrBuilder &B);
void UpgradeFramePointerAttributes(AttrBuilder &B);
} // End llvm namespace } // End llvm namespace
#endif #endif

llvm/lib/AsmParser/LLLexer.cpp

Show First 20 Lines • Show All 659 Lines • ▼ Show 20 Lines#define KEYWORD(STR) \
KEYWORD(nonlazybind); KEYWORD(nonlazybind);
KEYWORD(nomerge); KEYWORD(nomerge);
KEYWORD(nonnull); KEYWORD(nonnull);
KEYWORD(noredzone); KEYWORD(noredzone);
KEYWORD(noreturn); KEYWORD(noreturn);
KEYWORD(nosync); KEYWORD(nosync);
KEYWORD(nocf_check); KEYWORD(nocf_check);
KEYWORD(nounwind); KEYWORD(nounwind);
KEYWORD(null_pointer_is_valid);
KEYWORD(optforfuzzing); KEYWORD(optforfuzzing);
KEYWORD(optnone); KEYWORD(optnone);
KEYWORD(optsize); KEYWORD(optsize);
KEYWORD(preallocated); KEYWORD(preallocated);
KEYWORD(readnone); KEYWORD(readnone);
KEYWORD(readonly); KEYWORD(readonly);
KEYWORD(returned); KEYWORD(returned);
KEYWORD(returns_twice); KEYWORD(returns_twice);
▲ Show 20 Lines • Show All 485 Lines • Show Last 20 Lines

llvm/lib/AsmParser/LLParser.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,310 Lines • ▼ Show 20 Lines while (true) {
case lltok::kw_nonlazybind: B.addAttribute(Attribute::NonLazyBind); break; case lltok::kw_nonlazybind: B.addAttribute(Attribute::NonLazyBind); break;
case lltok::kw_nomerge: B.addAttribute(Attribute::NoMerge); break; case lltok::kw_nomerge: B.addAttribute(Attribute::NoMerge); break;
case lltok::kw_noredzone: B.addAttribute(Attribute::NoRedZone); break; case lltok::kw_noredzone: B.addAttribute(Attribute::NoRedZone); break;
case lltok::kw_noreturn: B.addAttribute(Attribute::NoReturn); break; case lltok::kw_noreturn: B.addAttribute(Attribute::NoReturn); break;
case lltok::kw_nosync: B.addAttribute(Attribute::NoSync); break; case lltok::kw_nosync: B.addAttribute(Attribute::NoSync); break;
case lltok::kw_nocf_check: B.addAttribute(Attribute::NoCfCheck); break; case lltok::kw_nocf_check: B.addAttribute(Attribute::NoCfCheck); break;
case lltok::kw_norecurse: B.addAttribute(Attribute::NoRecurse); break; case lltok::kw_norecurse: B.addAttribute(Attribute::NoRecurse); break;
case lltok::kw_nounwind: B.addAttribute(Attribute::NoUnwind); break; case lltok::kw_nounwind: B.addAttribute(Attribute::NoUnwind); break;
case lltok::kw_null_pointer_is_valid:
B.addAttribute(Attribute::NullPointerIsValid); break;
case lltok::kw_optforfuzzing: case lltok::kw_optforfuzzing:
B.addAttribute(Attribute::OptForFuzzing); break; B.addAttribute(Attribute::OptForFuzzing); break;
case lltok::kw_optnone: B.addAttribute(Attribute::OptimizeNone); break; case lltok::kw_optnone: B.addAttribute(Attribute::OptimizeNone); break;
case lltok::kw_optsize: B.addAttribute(Attribute::OptimizeForSize); break; case lltok::kw_optsize: B.addAttribute(Attribute::OptimizeForSize); break;
case lltok::kw_readnone: B.addAttribute(Attribute::ReadNone); break; case lltok::kw_readnone: B.addAttribute(Attribute::ReadNone); break;
case lltok::kw_readonly: B.addAttribute(Attribute::ReadOnly); break; case lltok::kw_readonly: B.addAttribute(Attribute::ReadOnly); break;
case lltok::kw_returns_twice: case lltok::kw_returns_twice:
B.addAttribute(Attribute::ReturnsTwice); break; B.addAttribute(Attribute::ReturnsTwice); break;
▲ Show 20 Lines • Show All 7,682 Lines • Show Last 20 Lines

llvm/lib/AsmParser/LLToken.h

Show First 20 Lines • Show All 205 Lines • ▼ Show 20 Linesenum Kind {
kw_nonlazybind, kw_nonlazybind,
kw_nomerge, kw_nomerge,
kw_nonnull, kw_nonnull,
kw_noredzone, kw_noredzone,
kw_noreturn, kw_noreturn,
kw_nosync, kw_nosync,
kw_nocf_check, kw_nocf_check,
kw_nounwind, kw_nounwind,
kw_null_pointer_is_valid,
kw_optforfuzzing, kw_optforfuzzing,
kw_optnone, kw_optnone,
kw_optsize, kw_optsize,
kw_preallocated, kw_preallocated,
kw_readnone, kw_readnone,
kw_readonly, kw_readonly,
kw_returned, kw_returned,
kw_returns_twice, kw_returns_twice,
▲ Show 20 Lines • Show All 258 Lines • Show Last 20 Lines

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

Show First 20 Lines • Show All 1,295 Lines • ▼ Show 20 Linesstatic uint64_t getRawAttributeMask(Attribute::AttrKind Val) {
} }
llvm_unreachable("Unsupported attribute type"); llvm_unreachable("Unsupported attribute type");
} }
static void addRawAttributeValue(AttrBuilder &B, uint64_t Val) { static void addRawAttributeValue(AttrBuilder &B, uint64_t Val) {
if (!Val) return; if (!Val) return;
for (Attribute::AttrKind I = Attribute::None; I != Attribute::EndAttrKinds; for (Attribute::AttrKind I = Attribute::None; I != Attribute::EndAttrKinds;
I = Attribute::AttrKind(I + 1)) { I = Attribute::AttrKind(I + 1)) {
if (uint64_t A = (Val & getRawAttributeMask(I))) { if (uint64_t A = (Val & getRawAttributeMask(I))) {
jdoerfertUnsubmitted
Done
ReplyInline Actions

I guess this change can go in as NFC simplification right away.

jdoerfert: I guess this change can go in as NFC simplification right away.
if (I == Attribute::Alignment) if (I == Attribute::Alignment)
B.addAlignmentAttr(1ULL << ((A >> 16) - 1)); B.addAlignmentAttr(1ULL << ((A >> 16) - 1));
else if (I == Attribute::StackAlignment) else if (I == Attribute::StackAlignment)
B.addStackAlignmentAttr(1ULL << ((A >> 26)-1)); B.addStackAlignmentAttr(1ULL << ((A >> 26)-1));
else else
B.addAttribute(I); B.addAttribute(I);
} }
} }
▲ Show 20 Lines • Show All 150 Lines • ▼ Show 20 Linesstatic Attribute::AttrKind getAttrFromCode(uint64_t Code) {
case bitc::ATTR_KIND_NO_RETURN: case bitc::ATTR_KIND_NO_RETURN:
return Attribute::NoReturn; return Attribute::NoReturn;
case bitc::ATTR_KIND_NOSYNC: case bitc::ATTR_KIND_NOSYNC:
return Attribute::NoSync; return Attribute::NoSync;
case bitc::ATTR_KIND_NOCF_CHECK: case bitc::ATTR_KIND_NOCF_CHECK:
return Attribute::NoCfCheck; return Attribute::NoCfCheck;
case bitc::ATTR_KIND_NO_UNWIND: case bitc::ATTR_KIND_NO_UNWIND:
return Attribute::NoUnwind; return Attribute::NoUnwind;
case bitc::ATTR_KIND_NULL_POINTER_IS_VALID:
return Attribute::NullPointerIsValid;
case bitc::ATTR_KIND_OPT_FOR_FUZZING: case bitc::ATTR_KIND_OPT_FOR_FUZZING:
return Attribute::OptForFuzzing; return Attribute::OptForFuzzing;
case bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE: case bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE:
return Attribute::OptimizeForSize; return Attribute::OptimizeForSize;
case bitc::ATTR_KIND_OPTIMIZE_NONE: case bitc::ATTR_KIND_OPTIMIZE_NONE:
return Attribute::OptimizeNone; return Attribute::OptimizeNone;
case bitc::ATTR_KIND_READ_NONE: case bitc::ATTR_KIND_READ_NONE:
return Attribute::ReadNone; return Attribute::ReadNone;
▲ Show 20 Lines • Show All 169 Lines • ▼ Show 20 Lines case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...]
if (Kind == Attribute::ByVal) { if (Kind == Attribute::ByVal) {
B.addByValAttr(HasType ? getTypeByID(Record[++i]) : nullptr); B.addByValAttr(HasType ? getTypeByID(Record[++i]) : nullptr);
} else if (Kind == Attribute::Preallocated) { } else if (Kind == Attribute::Preallocated) {
B.addPreallocatedAttr(getTypeByID(Record[++i])); B.addPreallocatedAttr(getTypeByID(Record[++i]));
} }
} }
} }
UpgradeFramePointerAttributes(B); UpgradeAttributes(B);
MAttributeGroups[GrpID] = AttributeList::get(Context, Idx, B); MAttributeGroups[GrpID] = AttributeList::get(Context, Idx, B);
break; break;
} }
} }
} }
} }
Error BitcodeReader::parseTypeTable() { Error BitcodeReader::parseTypeTable() {
▲ Show 20 Lines • Show All 5,123 Lines • Show Last 20 Lines

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

Show First 20 Lines • Show All 661 Lines • ▼ Show 20 Linesstatic uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
case Attribute::NoReturn: case Attribute::NoReturn:
return bitc::ATTR_KIND_NO_RETURN; return bitc::ATTR_KIND_NO_RETURN;
case Attribute::NoSync: case Attribute::NoSync:
return bitc::ATTR_KIND_NOSYNC; return bitc::ATTR_KIND_NOSYNC;
case Attribute::NoCfCheck: case Attribute::NoCfCheck:
return bitc::ATTR_KIND_NOCF_CHECK; return bitc::ATTR_KIND_NOCF_CHECK;
case Attribute::NoUnwind: case Attribute::NoUnwind:
return bitc::ATTR_KIND_NO_UNWIND; return bitc::ATTR_KIND_NO_UNWIND;
case Attribute::NullPointerIsValid:
return bitc::ATTR_KIND_NULL_POINTER_IS_VALID;
case Attribute::OptForFuzzing: case Attribute::OptForFuzzing:
return bitc::ATTR_KIND_OPT_FOR_FUZZING; return bitc::ATTR_KIND_OPT_FOR_FUZZING;
case Attribute::OptimizeForSize: case Attribute::OptimizeForSize:
return bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE; return bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE;
case Attribute::OptimizeNone: case Attribute::OptimizeNone:
return bitc::ATTR_KIND_OPTIMIZE_NONE; return bitc::ATTR_KIND_OPTIMIZE_NONE;
case Attribute::ReadNone: case Attribute::ReadNone:
return bitc::ATTR_KIND_READ_NONE; return bitc::ATTR_KIND_READ_NONE;
▲ Show 20 Lines • Show All 4,137 Lines • Show Last 20 Lines

llvm/lib/IR/Attributes.cpp

Show First 20 Lines • Show All 379 Lines • ▼ Show 20 Linesstd::string Attribute::getAsString(bool InAttrGrp) const {
if (hasAttribute(Attribute::NonNull)) if (hasAttribute(Attribute::NonNull))
return "nonnull"; return "nonnull";
if (hasAttribute(Attribute::NoRedZone)) if (hasAttribute(Attribute::NoRedZone))
return "noredzone"; return "noredzone";
if (hasAttribute(Attribute::NoReturn)) if (hasAttribute(Attribute::NoReturn))
return "noreturn"; return "noreturn";
if (hasAttribute(Attribute::NoSync)) if (hasAttribute(Attribute::NoSync))
return "nosync"; return "nosync";
if (hasAttribute(Attribute::NullPointerIsValid))
return "null_pointer_is_valid";
if (hasAttribute(Attribute::WillReturn)) if (hasAttribute(Attribute::WillReturn))
return "willreturn"; return "willreturn";
if (hasAttribute(Attribute::NoCfCheck)) if (hasAttribute(Attribute::NoCfCheck))
return "nocf_check"; return "nocf_check";
if (hasAttribute(Attribute::NoRecurse)) if (hasAttribute(Attribute::NoRecurse))
return "norecurse"; return "norecurse";
if (hasAttribute(Attribute::NoUnwind)) if (hasAttribute(Attribute::NoUnwind))
return "nounwind"; return "nounwind";
▲ Show 20 Lines • Show All 1,529 Lines • ▼ Show 20 Lines if (Caller.hasFnAttribute("min-legal-vector-width")) {
} else { } else {
// If the callee doesn't have the attribute then we don't know anything // If the callee doesn't have the attribute then we don't know anything
// and must drop the attribute from the caller. // and must drop the attribute from the caller.
Caller.removeFnAttr("min-legal-vector-width"); Caller.removeFnAttr("min-legal-vector-width");
} }
} }
} }
/// If the inlined function has "null-pointer-is-valid=true" attribute, /// If the inlined function has null_pointer_is_valid attribute,
/// set this attribute in the caller post inlining. /// set this attribute in the caller post inlining.
static void static void
adjustNullPointerValidAttr(Function &Caller, const Function &Callee) { adjustNullPointerValidAttr(Function &Caller, const Function &Callee) {
if (Callee.nullPointerIsDefined() && !Caller.nullPointerIsDefined()) { if (Callee.nullPointerIsDefined() && !Caller.nullPointerIsDefined()) {
Caller.addFnAttr(Callee.getFnAttribute("null-pointer-is-valid")); Caller.addFnAttr(Attribute::NullPointerIsValid);
} }
} }
struct EnumAttr { struct EnumAttr {
static bool isSet(const Function &Fn, static bool isSet(const Function &Fn,
Attribute::AttrKind Kind) { Attribute::AttrKind Kind) {
return Fn.hasFnAttribute(Kind); return Fn.hasFnAttribute(Kind);
} }
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/lib/IR/AutoUpgrade.cpp

Show First 20 Lines • Show All 4,239 Lines • ▼ Show 20 Linesstd::string llvm::UpgradeDataLayoutString(StringRef DL, StringRef TT) {
if (!R.match(DL, &Groups)) if (!R.match(DL, &Groups))
return std::string(DL); return std::string(DL);
SmallString<1024> Buf; SmallString<1024> Buf;
std::string Res = (Groups[1] + AddrSpaces + Groups[3]).toStringRef(Buf).str(); std::string Res = (Groups[1] + AddrSpaces + Groups[3]).toStringRef(Buf).str();
return Res; return Res;
} }
void llvm::UpgradeFramePointerAttributes(AttrBuilder &B) { void llvm::UpgradeAttributes(AttrBuilder &B) {
StringRef FramePointer; StringRef FramePointer;
if (B.contains("no-frame-pointer-elim")) { if (B.contains("no-frame-pointer-elim")) {
// The value can be "true" or "false". // The value can be "true" or "false".
for (const auto &I : B.td_attrs()) for (const auto &I : B.td_attrs())
if (I.first == "no-frame-pointer-elim") if (I.first == "no-frame-pointer-elim")
FramePointer = I.second == "true" ? "all" : "none"; FramePointer = I.second == "true" ? "all" : "none";
B.removeAttribute("no-frame-pointer-elim"); B.removeAttribute("no-frame-pointer-elim");
} }
if (B.contains("no-frame-pointer-elim-non-leaf")) { if (B.contains("no-frame-pointer-elim-non-leaf")) {
// The value is ignored. "no-frame-pointer-elim"="true" takes priority. // The value is ignored. "no-frame-pointer-elim"="true" takes priority.
if (FramePointer != "all") if (FramePointer != "all")
FramePointer = "non-leaf"; FramePointer = "non-leaf";
B.removeAttribute("no-frame-pointer-elim-non-leaf"); B.removeAttribute("no-frame-pointer-elim-non-leaf");
} }
if (!FramePointer.empty()) if (!FramePointer.empty())
B.addAttribute("frame-pointer", FramePointer); B.addAttribute("frame-pointer", FramePointer);
if (B.contains("null-pointer-is-valid")) {
// The value can be "true" or "false".
bool NullPointerIsValid = false;
for (const auto &I : B.td_attrs())
if (I.first == "null-pointer-is-valid")
NullPointerIsValid = I.second == "true";
B.removeAttribute("null-pointer-is-valid");
if (NullPointerIsValid)
B.addAttribute(Attribute::NullPointerIsValid);
}
} }

llvm/lib/IR/Function.cpp

Show First 20 Lines • Show All 1,635 Lines • ▼ Show 20 Lines assert(cast<MDString>(MD->getOperand(0))
.equals("function_section_prefix") && .equals("function_section_prefix") &&
"Metadata not match"); "Metadata not match");
return cast<MDString>(MD->getOperand(1))->getString(); return cast<MDString>(MD->getOperand(1))->getString();
} }
return None; return None;
} }
bool Function::nullPointerIsDefined() const { bool Function::nullPointerIsDefined() const {
return getFnAttribute("null-pointer-is-valid") return hasFnAttribute(Attribute::NullPointerIsValid);
.getValueAsString()
.equals("true");
} }
bool llvm::NullPointerIsDefined(const Function *F, unsigned AS) { bool llvm::NullPointerIsDefined(const Function *F, unsigned AS) {
if (F && F->nullPointerIsDefined()) if (F && F->nullPointerIsDefined())
return true; return true;
if (AS != 0) if (AS != 0)
return true; return true;
return false; return false;
} }

llvm/lib/IR/Verifier.cpp

Show First 20 Lines • Show All 1,557 Lines • ▼ Show 20 Linesstatic bool isFuncOnlyAttr(Attribute::AttrKind Kind) {
case Attribute::ArgMemOnly: case Attribute::ArgMemOnly:
case Attribute::NoRecurse: case Attribute::NoRecurse:
case Attribute::InaccessibleMemOnly: case Attribute::InaccessibleMemOnly:
case Attribute::InaccessibleMemOrArgMemOnly: case Attribute::InaccessibleMemOrArgMemOnly:
case Attribute::AllocSize: case Attribute::AllocSize:
case Attribute::SpeculativeLoadHardening: case Attribute::SpeculativeLoadHardening:
case Attribute::Speculatable: case Attribute::Speculatable:
case Attribute::StrictFP: case Attribute::StrictFP:
case Attribute::NullPointerIsValid:
return true; return true;
default: default:
break; break;
} }
return false; return false;
} }
/// Return true if this is a function attribute that can also appear on /// Return true if this is a function attribute that can also appear on
▲ Show 20 Lines • Show All 4,204 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/CodeExtractor.cpp

Show First 20 Lines • Show All 905 Lines • ▼ Show 20 Lines if (Attr.isStringAttribute()) {
case Attribute::MinSize: case Attribute::MinSize:
case Attribute::NoDuplicate: case Attribute::NoDuplicate:
case Attribute::NoFree: case Attribute::NoFree:
case Attribute::NoImplicitFloat: case Attribute::NoImplicitFloat:
case Attribute::NoInline: case Attribute::NoInline:
case Attribute::NonLazyBind: case Attribute::NonLazyBind:
case Attribute::NoRedZone: case Attribute::NoRedZone:
case Attribute::NoUnwind: case Attribute::NoUnwind:
case Attribute::NullPointerIsValid:
case Attribute::OptForFuzzing: case Attribute::OptForFuzzing:
case Attribute::OptimizeNone: case Attribute::OptimizeNone:
case Attribute::OptimizeForSize: case Attribute::OptimizeForSize:
case Attribute::SafeStack: case Attribute::SafeStack:
case Attribute::ShadowCallStack: case Attribute::ShadowCallStack:
case Attribute::SanitizeAddress: case Attribute::SanitizeAddress:
case Attribute::SanitizeMemory: case Attribute::SanitizeMemory:
case Attribute::SanitizeThread: case Attribute::SanitizeThread:
▲ Show 20 Lines • Show All 837 Lines • Show Last 20 Lines

llvm/test/Analysis/MemorySSA/cyclicphi.ll

Show First 20 Lines • Show All 146 Lines • ▼ Show 20 Lines; CHECK-NEXT: store i64 %tmp69, i64* %g, align 8
br label %bb77 br label %bb77
bb77: ; preds = %bb68, %bb26 bb77: ; preds = %bb68, %bb26
; CHECK: 2 = MemoryPhi({bb26,3},{bb68,1}) ; CHECK: 2 = MemoryPhi({bb26,3},{bb68,1})
; CHECK-NEXT: br label %bb26 ; CHECK-NEXT: br label %bb26
br label %bb26 br label %bb26
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Analysis/ValueTracking/assume.ll

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines3: ; preds = %1
%4 = load i32, i32* %0, align 4 %4 = load i32, i32* %0, align 4
br label %5 br label %5
5: ; preds = %1, %3 5: ; preds = %1, %3
%6 = phi i32 [ %4, %3 ], [ 0, %A ] %6 = phi i32 [ %4, %3 ], [ 0, %A ]
ret i32 %6 ret i32 %6
} }
define dso_local i32 @test4b(i32* readonly %0, i1 %cond) "null-pointer-is-valid"="true" { define dso_local i32 @test4b(i32* readonly %0, i1 %cond) null_pointer_is_valid {
; CHECK-LABEL: @test4b( ; CHECK-LABEL: @test4b(
; CHECK-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[TMP0:%.*]], i32 4) ] ; CHECK-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[TMP0:%.*]], i32 4) ]
; CHECK-NEXT: br i1 [[COND:%.*]], label [[A:%.*]], label [[B:%.*]] ; CHECK-NEXT: br i1 [[COND:%.*]], label [[A:%.*]], label [[B:%.*]]
; CHECK: B: ; CHECK: B:
; CHECK-NEXT: br label [[A]] ; CHECK-NEXT: br label [[A]]
; CHECK: A: ; CHECK: A:
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32* [[TMP0]], null ; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32* [[TMP0]], null
; CHECK-NEXT: br i1 [[TMP2]], label [[TMP5:%.*]], label [[TMP3:%.*]] ; CHECK-NEXT: br i1 [[TMP2]], label [[TMP5:%.*]], label [[TMP3:%.*]]
Show All 25 Lines

llvm/test/Bitcode/attributes.ll

Show First 20 Lines • Show All 374 Lines • ▼ Show 20 Lines
} }
; CHECK: define void @f64(i32* preallocated(i32) %a) ; CHECK: define void @f64(i32* preallocated(i32) %a)
define void @f64(i32* preallocated(i32) %a) define void @f64(i32* preallocated(i32) %a)
{ {
ret void ret void
} }
; CHECK: define void @f65() #40
define void @f65() null_pointer_is_valid
{
ret void;
}
; CHECK: attributes #0 = { noreturn } ; CHECK: attributes #0 = { noreturn }
; CHECK: attributes #1 = { nounwind } ; CHECK: attributes #1 = { nounwind }
; CHECK: attributes #2 = { readnone } ; CHECK: attributes #2 = { readnone }
; CHECK: attributes #3 = { readonly } ; CHECK: attributes #3 = { readonly }
; CHECK: attributes #4 = { noinline } ; CHECK: attributes #4 = { noinline }
; CHECK: attributes #5 = { alwaysinline } ; CHECK: attributes #5 = { alwaysinline }
; CHECK: attributes #6 = { optsize } ; CHECK: attributes #6 = { optsize }
; CHECK: attributes #7 = { ssp } ; CHECK: attributes #7 = { ssp }
Show All 24 Lines
; CHECK: attributes #32 = { writeonly } ; CHECK: attributes #32 = { writeonly }
; CHECK: attributes #33 = { speculatable } ; CHECK: attributes #33 = { speculatable }
; CHECK: attributes #34 = { sanitize_hwaddress } ; CHECK: attributes #34 = { sanitize_hwaddress }
; CHECK: attributes #35 = { shadowcallstack } ; CHECK: attributes #35 = { shadowcallstack }
; CHECK: attributes #36 = { willreturn } ; CHECK: attributes #36 = { willreturn }
; CHECK: attributes #37 = { nofree } ; CHECK: attributes #37 = { nofree }
; CHECK: attributes #38 = { nosync } ; CHECK: attributes #38 = { nosync }
; CHECK: attributes #39 = { sanitize_memtag } ; CHECK: attributes #39 = { sanitize_memtag }
; CHECK: attributes #40 = { null_pointer_is_valid }
; CHECK: attributes #[[NOBUILTIN]] = { nobuiltin } ; CHECK: attributes #[[NOBUILTIN]] = { nobuiltin }

llvm/test/Transforms/Attributor/IPConstantProp/PR26044.ll

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
; CHECK-NEXT: ret i32 [[COND]] ; CHECK-NEXT: ret i32 [[COND]]
; ;
entry: entry:
%tobool = icmp ne i32 %p1, 0 %tobool = icmp ne i32 %p1, 0
%cond = select i1 %tobool, i32 %p1, i32 %p1 %cond = select i1 %tobool, i32 %p1, i32 %p1
ret i32 %cond ret i32 %cond
} }
define void @fn_no_null_opt(i32* %P, i1 %C) "null-pointer-is-valid"="true" { define void @fn_no_null_opt(i32* %P, i1 %C) null_pointer_is_valid {
; ;
; IS__TUNIT____-LABEL: define {{[^@]+}}@fn_no_null_opt ; IS__TUNIT____-LABEL: define {{[^@]+}}@fn_no_null_opt
; IS__TUNIT____-SAME: (i32* nocapture nofree writeonly [[P:%.*]], i1 [[C:%.*]]) ; IS__TUNIT____-SAME: (i32* nocapture nofree writeonly [[P:%.*]], i1 [[C:%.*]])
; IS__TUNIT____-NEXT: entry: ; IS__TUNIT____-NEXT: entry:
; IS__TUNIT____-NEXT: br label [[IF_END:%.*]] ; IS__TUNIT____-NEXT: br label [[IF_END:%.*]]
; IS__TUNIT____: for.cond1: ; IS__TUNIT____: for.cond1:
; IS__TUNIT____-NEXT: br i1 [[C]], label [[IF_END]], label [[EXIT:%.*]] ; IS__TUNIT____-NEXT: br i1 [[C]], label [[IF_END]], label [[EXIT:%.*]]
; IS__TUNIT____: if.end: ; IS__TUNIT____: if.end:
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/align.ll

Show First 20 Lines • Show All 773 Lines • ▼ Show 20 Linesmt:
%v = musttail call i32 @musttail_callee_1(i32* %p) %v = musttail call i32 @musttail_callee_1(i32* %p)
ret i32 %v ret i32 %v
exit: exit:
ret i32 0 ret i32 0
} }
attributes #0 = { nounwind uwtable noinline } attributes #0 = { nounwind uwtable noinline }
attributes #1 = { uwtable noinline } attributes #1 = { uwtable noinline }
attributes #2 = { "null-pointer-is-valid"="true" } attributes #2 = { null_pointer_is_valid }

llvm/test/Transforms/Attributor/nocapture-1.ll

Show First 20 Lines • Show All 522 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8* [[TMP1]], null ; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8* [[TMP1]], null
; CHECK-NEXT: ret i1 [[TMP2]] ; CHECK-NEXT: ret i1 [[TMP2]]
; ;
%1 = bitcast i32* %x to i8* %1 = bitcast i32* %x to i8*
%2 = icmp eq i8* %1, null %2 = icmp eq i8* %1, null
ret i1 %2 ret i1 %2
} }
define i1 @captureDereferenceableOrNullICmp(i32* dereferenceable_or_null(4) %x) "null-pointer-is-valid"="true" { define i1 @captureDereferenceableOrNullICmp(i32* dereferenceable_or_null(4) %x) null_pointer_is_valid {
; CHECK-LABEL: define {{[^@]+}}@captureDereferenceableOrNullICmp ; CHECK-LABEL: define {{[^@]+}}@captureDereferenceableOrNullICmp
; CHECK-SAME: (i32* nofree readnone dereferenceable_or_null(4) [[X:%.*]]) ; CHECK-SAME: (i32* nofree readnone dereferenceable_or_null(4) [[X:%.*]])
; CHECK-NEXT: [[TMP1:%.*]] = bitcast i32* [[X]] to i8* ; CHECK-NEXT: [[TMP1:%.*]] = bitcast i32* [[X]] to i8*
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8* [[TMP1]], null ; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8* [[TMP1]], null
; CHECK-NEXT: ret i1 [[TMP2]] ; CHECK-NEXT: ret i1 [[TMP2]]
; ;
%1 = bitcast i32* %x to i8* %1 = bitcast i32* %x to i8*
%2 = icmp eq i8* %1, null %2 = icmp eq i8* %1, null
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/nonnull.ll

Show First 20 Lines • Show All 1,225 Lines • ▼ Show 20 Lines;
call void @use_i8_ptr_ret(i8* %arg) call void @use_i8_ptr_ret(i8* %arg)
call void @llvm.assume(i1 true) ["nonnull"(i8* %arg)] call void @llvm.assume(i1 true) ["nonnull"(i8* %arg)]
call void @use_i8_ptr_ret(i8* %arg) call void @use_i8_ptr_ret(i8* %arg)
ret void ret void
} }
declare void @use_i8_ptr(i8* nofree nocapture readnone) nounwind declare void @use_i8_ptr(i8* nofree nocapture readnone) nounwind
declare void @use_i8_ptr_ret(i8* nofree nocapture readnone) nounwind willreturn declare void @use_i8_ptr_ret(i8* nofree nocapture readnone) nounwind willreturn
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }
attributes #1 = { nounwind willreturn} attributes #1 = { nounwind willreturn}

llvm/test/Transforms/Attributor/norecurse.ll

Show First 20 Lines • Show All 205 Lines • ▼ Show 20 Lines
; CHECK-SAME: (i32 (i32)* nocapture nofree nonnull [[TMP0:%.*]], i32 [[TMP1:%.*]]) local_unnamed_addr ; CHECK-SAME: (i32 (i32)* nocapture nofree nonnull [[TMP0:%.*]], i32 [[TMP1:%.*]]) local_unnamed_addr
; CHECK-NEXT: [[TMP3:%.*]] = tail call i32 [[TMP0]](i32 [[TMP1]]) ; CHECK-NEXT: [[TMP3:%.*]] = tail call i32 [[TMP0]](i32 [[TMP1]])
; CHECK-NEXT: ret i32 [[TMP3]] ; CHECK-NEXT: ret i32 [[TMP3]]
; ;
%3 = tail call i32 %0(i32 %1) #2 %3 = tail call i32 %0(i32 %1) #2
ret i32 %3 ret i32 %3
} }
; CHECK-NOT: Function Attrs ; CHECK: Function Attrs: null_pointer_is_valid
define i32 @eval_func2(i32 (i32)* , i32) local_unnamed_addr "null-pointer-is-valid"="true"{ define i32 @eval_func2(i32 (i32)* , i32) local_unnamed_addr null_pointer_is_valid{
; CHECK-LABEL: define {{[^@]+}}@eval_func2 ; CHECK-LABEL: define {{[^@]+}}@eval_func2
; CHECK-SAME: (i32 (i32)* nocapture nofree [[TMP0:%.*]], i32 [[TMP1:%.*]]) local_unnamed_addr ; CHECK-SAME: (i32 (i32)* nocapture nofree [[TMP0:%.*]], i32 [[TMP1:%.*]]) local_unnamed_addr
; CHECK-NEXT: [[TMP3:%.*]] = tail call i32 [[TMP0]](i32 [[TMP1]]) ; CHECK-NEXT: [[TMP3:%.*]] = tail call i32 [[TMP0]](i32 [[TMP1]])
; CHECK-NEXT: ret i32 [[TMP3]] ; CHECK-NEXT: ret i32 [[TMP3]]
; ;
%3 = tail call i32 %0(i32 %1) #2 %3 = tail call i32 %0(i32 %1) #2
ret i32 %3 ret i32 %3
} }
Show All 16 Lines

llvm/test/Transforms/Attributor/undefined_behavior.ll

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Linest:
%b = load i32, i32* null %b = load i32, i32* null
br label %e br label %e
e: e:
ret void ret void
} }
; Note that while the load is removed (because it's unused), the block ; Note that while the load is removed (because it's unused), the block
; is not changed to unreachable ; is not changed to unreachable
define void @load_null_pointer_is_defined() "null-pointer-is-valid"="true" { define void @load_null_pointer_is_defined() null_pointer_is_valid {
; CHECK-LABEL: define {{[^@]+}}@load_null_pointer_is_defined() ; CHECK-LABEL: define {{[^@]+}}@load_null_pointer_is_defined()
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%a = load i32, i32* null %a = load i32, i32* null
ret void ret void
} }
define internal i32* @ret_null() { define internal i32* @ret_null() {
Show All 34 Lines;
br i1 %cond, label %t, label %e br i1 %cond, label %t, label %e
t: t:
store i32 5, i32* null store i32 5, i32* null
br label %e br label %e
e: e:
ret void ret void
} }
define void @store_null_pointer_is_defined() "null-pointer-is-valid"="true" { define void @store_null_pointer_is_defined() null_pointer_is_valid {
; CHECK-LABEL: define {{[^@]+}}@store_null_pointer_is_defined() ; CHECK-LABEL: define {{[^@]+}}@store_null_pointer_is_defined()
; CHECK-NEXT: store i32 5, i32* null, align 536870912 ; CHECK-NEXT: store i32 5, i32* null, align 536870912
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store i32 5, i32* null store i32 5, i32* null
ret void ret void
} }
Show All 31 Lines;
br i1 %cond, label %t, label %e br i1 %cond, label %t, label %e
t: t:
%a = atomicrmw add i32* null, i32 1 acquire %a = atomicrmw add i32* null, i32 1 acquire
br label %e br label %e
e: e:
ret void ret void
} }
define void @atomicrmw_null_pointer_is_defined() "null-pointer-is-valid"="true" { define void @atomicrmw_null_pointer_is_defined() null_pointer_is_valid {
; CHECK-LABEL: define {{[^@]+}}@atomicrmw_null_pointer_is_defined() ; CHECK-LABEL: define {{[^@]+}}@atomicrmw_null_pointer_is_defined()
; CHECK-NEXT: [[A:%.*]] = atomicrmw add i32* null, i32 1 acquire ; CHECK-NEXT: [[A:%.*]] = atomicrmw add i32* null, i32 1 acquire
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%a = atomicrmw add i32* null, i32 1 acquire %a = atomicrmw add i32* null, i32 1 acquire
ret void ret void
} }
Show All 31 Lines;
br i1 %cond, label %t, label %e br i1 %cond, label %t, label %e
t: t:
%a = cmpxchg i32* null, i32 2, i32 3 acq_rel monotonic %a = cmpxchg i32* null, i32 2, i32 3 acq_rel monotonic
br label %e br label %e
e: e:
ret void ret void
} }
define void @atomiccmpxchg_null_pointer_is_defined() "null-pointer-is-valid"="true" { define void @atomiccmpxchg_null_pointer_is_defined() null_pointer_is_valid {
; CHECK-LABEL: define {{[^@]+}}@atomiccmpxchg_null_pointer_is_defined() ; CHECK-LABEL: define {{[^@]+}}@atomiccmpxchg_null_pointer_is_defined()
; CHECK-NEXT: [[A:%.*]] = cmpxchg i32* null, i32 2, i32 3 acq_rel monotonic ; CHECK-NEXT: [[A:%.*]] = cmpxchg i32* null, i32 2, i32 3 acq_rel monotonic
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%a = cmpxchg i32* null, i32 2, i32 3 acq_rel monotonic %a = cmpxchg i32* null, i32 2, i32 3 acq_rel monotonic
ret void ret void
} }
▲ Show 20 Lines • Show All 184 Lines • Show Last 20 Lines

llvm/test/Transforms/CorrelatedValuePropagation/non-null.ll

Show First 20 Lines • Show All 327 Lines • ▼ Show 20 Linesnull:
br label %merge br label %merge
merge: merge:
%merged_arg = phi i8* [%another_arg, %null], [%arg1, %non_null] %merged_arg = phi i8* [%another_arg, %null], [%arg1, %non_null]
call void @test12_helper(i8* %merged_arg) call void @test12_helper(i8* %merged_arg)
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/FunctionAttrs/nocapture.ll

Show First 20 Lines • Show All 305 Lines • ▼ Show 20 Lines
; FNATTR: define i1 @nocaptureDereferenceableOrNullICmp(i32* nocapture readnone dereferenceable_or_null(4) %x) ; FNATTR: define i1 @nocaptureDereferenceableOrNullICmp(i32* nocapture readnone dereferenceable_or_null(4) %x)
define i1 @nocaptureDereferenceableOrNullICmp(i32* dereferenceable_or_null(4) %x) { define i1 @nocaptureDereferenceableOrNullICmp(i32* dereferenceable_or_null(4) %x) {
%1 = bitcast i32* %x to i8* %1 = bitcast i32* %x to i8*
%2 = icmp eq i8* %1, null %2 = icmp eq i8* %1, null
ret i1 %2 ret i1 %2
} }
; FNATTR: define i1 @captureDereferenceableOrNullICmp(i32* readnone dereferenceable_or_null(4) %x) ; FNATTR: define i1 @captureDereferenceableOrNullICmp(i32* readnone dereferenceable_or_null(4) %x)
define i1 @captureDereferenceableOrNullICmp(i32* dereferenceable_or_null(4) %x) "null-pointer-is-valid"="true" { define i1 @captureDereferenceableOrNullICmp(i32* dereferenceable_or_null(4) %x) null_pointer_is_valid {
%1 = bitcast i32* %x to i8* %1 = bitcast i32* %x to i8*
%2 = icmp eq i8* %1, null %2 = icmp eq i8* %1, null
ret i1 %2 ret i1 %2
} }
declare i8* @llvm.launder.invariant.group.p0i8(i8*) declare i8* @llvm.launder.invariant.group.p0i8(i8*)
declare i8* @llvm.strip.invariant.group.p0i8(i8*) declare i8* @llvm.strip.invariant.group.p0i8(i8*)

llvm/test/Transforms/FunctionAttrs/nonnull.ll

Show First 20 Lines • Show All 764 Lines • ▼ Show 20 Lines
8: ; preds = %8, %4 8: ; preds = %8, %4
%9 = phi i32 [ 1, %4 ], [ %10, %8 ] %9 = phi i32 [ 1, %4 ], [ %10, %8 ]
tail call void @sink(i32* %6) tail call void @sink(i32* %6)
%10 = add nuw nsw i32 %9, 1 %10 = add nuw nsw i32 %9, 1
%11 = icmp eq i32 %10, %1 %11 = icmp eq i32 %10, %1
br i1 %11, label %7, label %8 br i1 %11, label %7, label %8
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }
attributes #1 = { nounwind willreturn} attributes #1 = { nounwind willreturn}

llvm/test/Transforms/GVN/PRE/2018-06-08-pre-load-dbgloc-no-null-opt.ll

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines; ALL: phi i8* [ %2, %cond.false ], [ null, %entry.cond.end_crit_edge ]
%node2 = getelementptr inbounds %struct.desc, %struct.desc* %desc, i64 0, i32 0 %node2 = getelementptr inbounds %struct.desc, %struct.desc* %desc, i64 0, i32 0
%4 = load %struct.node*, %struct.node** %node2, align 8, !dbg !10 %4 = load %struct.node*, %struct.node** %node2, align 8, !dbg !10
%descs = getelementptr inbounds %struct.node, %struct.node* %4, i64 0, i32 1 %descs = getelementptr inbounds %struct.node, %struct.node* %4, i64 0, i32 1
%5 = bitcast %struct.desc** %descs to i8** %5 = bitcast %struct.desc** %descs to i8**
%6 = load i8*, i8** %5, align 8 %6 = load i8*, i8** %5, align 8
%call = tail call i32 @bar(i8* %3, i8* %6) %call = tail call i32 @bar(i8* %3, i8* %6)
ret i32 %call ret i32 %call
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }
declare i32 @bar(i8*, i8*) local_unnamed_addr #1 declare i32 @bar(i8*, i8*) local_unnamed_addr #1
!llvm.dbg.cu = !{!0} !llvm.dbg.cu = !{!0}
!llvm.module.flags = !{!2, !3} !llvm.module.flags = !{!2, !3}
!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, emissionKind: FullDebug) !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, emissionKind: FullDebug)
!1 = !DIFile(filename: "test.c", directory: ".") !1 = !DIFile(filename: "test.c", directory: ".")
!2 = !{i32 2, !"Dwarf Version", i32 4} !2 = !{i32 2, !"Dwarf Version", i32 4}
Show All 13 Lines

llvm/test/Transforms/GlobalOpt/MallocSROA-section-no-null-opt.ll

Show All 25 Lines
; CHECK: load %struct.xyz*, %struct.xyz** @Y ; CHECK: load %struct.xyz*, %struct.xyz** @Y
entry: entry:
%0 = load %struct.xyz*, %struct.xyz** @Y, align 8 ; <%struct.xyz*> [#uses=0] %0 = load %struct.xyz*, %struct.xyz** @Y, align 8 ; <%struct.xyz*> [#uses=0]
ret %struct.xyz* %0 ret %struct.xyz* %0
} }
declare noalias i8* @malloc(i32) declare noalias i8* @malloc(i32)
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/GlobalOpt/heap-sra-1-no-null-opt.ll

Show All 30 Linesbb1: ; preds = %bb1, %bb1.thread
%indvar.next = add i32 %i.0.reg2mem.0, 1 %indvar.next = add i32 %i.0.reg2mem.0, 1
%exitcond = icmp eq i32 %indvar.next, 1200 %exitcond = icmp eq i32 %indvar.next, 1200
br i1 %exitcond, label %bb2, label %bb1 br i1 %exitcond, label %bb2, label %bb1
bb2: ; preds = %bb1 bb2: ; preds = %bb1
ret i32 %3 ret i32 %3
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/GlobalOpt/heap-sra-1.ll

Show All 36 Lines
} }
define void @bam(i64 %Size) nounwind noinline #0 { define void @bam(i64 %Size) nounwind noinline #0 {
entry: entry:
%0 = load %struct.foo*, %struct.foo** @X, align 4 %0 = load %struct.foo*, %struct.foo** @X, align 4
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/GlobalOpt/heap-sra-2-no-null-opt.ll

Show All 30 Linesbb1: ; preds = %bb1, %bb1.thread
%indvar.next = add i32 %i.0.reg2mem.0, 1 ; <i32> [#uses=2] %indvar.next = add i32 %i.0.reg2mem.0, 1 ; <i32> [#uses=2]
%exitcond = icmp eq i32 %indvar.next, 1200 ; <i1> [#uses=1] %exitcond = icmp eq i32 %indvar.next, 1200 ; <i1> [#uses=1]
br i1 %exitcond, label %bb2, label %bb1 br i1 %exitcond, label %bb2, label %bb1
bb2: ; preds = %bb1 bb2: ; preds = %bb1
ret i32 %3 ret i32 %3
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/GlobalOpt/heap-sra-2.ll

Show All 36 Lines
} }
define void @bam(i64 %Size) nounwind noinline #0 { define void @bam(i64 %Size) nounwind noinline #0 {
entry: entry:
%0 = load %struct.foo*, %struct.foo** @X, align 4 %0 = load %struct.foo*, %struct.foo** @X, align 4
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/GlobalOpt/heap-sra-3-no-null-opt.ll

Show All 32 Linesbb1: ; preds = %bb1, %bb1.thread
%indvar.next = add i32 %i.0.reg2mem.0, 1 %indvar.next = add i32 %i.0.reg2mem.0, 1
%exitcond = icmp eq i32 %indvar.next, 1200 %exitcond = icmp eq i32 %indvar.next, 1200
br i1 %exitcond, label %bb2, label %bb1 br i1 %exitcond, label %bb2, label %bb1
bb2: ; preds = %bb1 bb2: ; preds = %bb1
ret i32 %3 ret i32 %3
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/GlobalOpt/heap-sra-3.ll

Show All 37 Lines
} }
define void @bam(i64 %Size) nounwind noinline #0 { define void @bam(i64 %Size) nounwind noinline #0 {
entry: entry:
%0 = load %struct.foo*, %struct.foo** @X, align 4 %0 = load %struct.foo*, %struct.foo** @X, align 4
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/GlobalOpt/heap-sra-4-no-null-opt.ll

Show All 35 Lines; CHECK: load i32, i32* %1, align 4
%indvar.next = add i32 %i.0.reg2mem.0, 1 %indvar.next = add i32 %i.0.reg2mem.0, 1
%exitcond = icmp eq i32 %indvar.next, 1200 %exitcond = icmp eq i32 %indvar.next, 1200
br i1 %exitcond, label %bb2, label %bb1 br i1 %exitcond, label %bb2, label %bb1
bb2: ; preds = %bb1 bb2: ; preds = %bb1
ret i32 %3 ret i32 %3
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/GlobalOpt/heap-sra-4.ll

Show All 37 Lines
} }
define void @bam(i64 %Size) nounwind noinline #0 { define void @bam(i64 %Size) nounwind noinline #0 {
entry: entry:
%0 = load %struct.foo*, %struct.foo** @X, align 4 %0 = load %struct.foo*, %struct.foo** @X, align 4
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/GlobalOpt/heap-sra-phi-no-null-opt.ll

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines; CHECK: load %struct.foo*, %struct.foo** @X, align 4
%exitcond = icmp eq i32 %indvar.next, 1200 ; <i1> [#uses=1] %exitcond = icmp eq i32 %indvar.next, 1200 ; <i1> [#uses=1]
br i1 %exitcond, label %bb2, label %bb1 br i1 %exitcond, label %bb2, label %bb1
bb2: ; preds = %bb1 bb2: ; preds = %bb1
ret i32 %tmp3 ret i32 %tmp3
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/GlobalOpt/heap-sra-phi.ll

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
} }
define void @bam(i64 %Size) nounwind noinline #0 { define void @bam(i64 %Size) nounwind noinline #0 {
entry: entry:
%0 = load %struct.foo*, %struct.foo** @X, align 4 %0 = load %struct.foo*, %struct.foo** @X, align 4
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/GlobalOpt/load-store-global-no-null-opt.ll

Show All 19 Lines
define i64* @bar() { define i64* @bar() {
%X = load i64*, i64** @a, align 8 %X = load i64*, i64** @a, align 8
ret i64* %X ret i64* %X
; CHECK-LABEL: @bar( ; CHECK-LABEL: @bar(
; CHECK: load ; CHECK: load
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/GlobalOpt/malloc-promote-1-no-null-opt.ll

Show All 22 Lines
; CHECK: load i32*, i32** @G ; CHECK: load i32*, i32** @G
; CHECK-NEXT: load i32, i32* %GV ; CHECK-NEXT: load i32, i32* %GV
%GV = load i32*, i32** @G ; <i32*> [#uses=1] %GV = load i32*, i32** @G ; <i32*> [#uses=1]
%V = load i32, i32* %GV ; <i32> [#uses=1] %V = load i32, i32* %GV ; <i32> [#uses=1]
ret i32 %V ret i32 %V
; CHECK: ret i32 %V ; CHECK: ret i32 %V
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/GlobalOpt/malloc-promote-1.ll

Show All 22 Lines
} }
define void @foo(i64 %Size) nounwind noinline #0 { define void @foo(i64 %Size) nounwind noinline #0 {
entry: entry:
%0 = load i32*, i32** @G, align 4 %0 = load i32*, i32** @G, align 4
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/GlobalOpt/malloc-promote-2-no-null-opt.ll

Show All 15 Lines; CHECK: store
store i32* %P, i32** @G store i32* %P, i32** @G
%GV = load i32*, i32** @G %GV = load i32*, i32** @G
%GVe = getelementptr i32, i32* %GV, i32 40 %GVe = getelementptr i32, i32* %GV, i32 40
store i32 20, i32* %GVe store i32 20, i32* %GVe
ret void ret void
} }
declare noalias i8* @malloc(i64) declare noalias i8* @malloc(i64)
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/GlobalOpt/malloc-promote-2.ll

Show All 18 Lines
declare noalias i8* @malloc(i64) declare noalias i8* @malloc(i64)
define void @foo(i64 %Size) nounwind noinline #0 { define void @foo(i64 %Size) nounwind noinline #0 {
entry: entry:
%0 = load i32*, i32** @G, align 4 %0 = load i32*, i32** @G, align 4
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/GlobalOpt/storepointer-compare-no-null-opt.ll

Show All 31 Lines; CHECK: ret void
ret void ret void
isNull: ; preds = %0 isNull: ; preds = %0
; CHECK: isNull: ; CHECK: isNull:
; CHECK: ret void ; CHECK: ret void
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/GlobalOpt/storepointer-no-null-opt.ll

Show All 18 Lines
; CHECK-LABEL: doit( ; CHECK-LABEL: doit(
; CHECK: %FP = load void ()*, void ()** @G ; CHECK: %FP = load void ()*, void ()** @G
; CHECK: call void %FP() ; CHECK: call void %FP()
%FP = load void ()*, void ()** @G ; <void ()*> [#uses=1] %FP = load void ()*, void ()** @G ; <void ()*> [#uses=1]
call void %FP( ) call void %FP( )
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/IPConstantProp/PR26044.ll

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Lines
; CHECK-NEXT: ret i32 [[COND]] ; CHECK-NEXT: ret i32 [[COND]]
; ;
entry: entry:
%tobool = icmp ne i32 %p1, 0 %tobool = icmp ne i32 %p1, 0
%cond = select i1 %tobool, i32 %p1, i32 %p1 %cond = select i1 %tobool, i32 %p1, i32 %p1
ret i32 %cond ret i32 %cond
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/Inline/attributes.ll

Show First 20 Lines • Show All 383 Lines • ▼ Show 20 Lines
define i32 @test_no-use-jump-tables3(i32 %i) "no-jump-tables"="true" { define i32 @test_no-use-jump-tables3(i32 %i) "no-jump-tables"="true" {
%1 = call i32 @no-use-jump-tables_callee1(i32 %i) %1 = call i32 @no-use-jump-tables_callee1(i32 %i)
ret i32 %1 ret i32 %1
; CHECK: @test_no-use-jump-tables3(i32 %i) [[NOUSEJUMPTABLES]] { ; CHECK: @test_no-use-jump-tables3(i32 %i) [[NOUSEJUMPTABLES]] {
; CHECK-NEXT: ret i32 ; CHECK-NEXT: ret i32
} }
; Callee with "null-pointer-is-valid"="true" attribute should not be inlined ; Callee with null_pointer_is_valid attribute should not be inlined
; into a caller without this attribute. ; into a caller without this attribute.
; Exception: alwaysinline callee can still be inlined but ; Exception: alwaysinline callee can still be inlined but
; "null-pointer-is-valid"="true" should get copied to caller. ; null_pointer_is_valid should get copied to caller.
define i32 @null-pointer-is-valid_callee0(i32 %i) "null-pointer-is-valid"="true" { define i32 @null-pointer-is-valid_callee0(i32 %i) null_pointer_is_valid {
ret i32 %i ret i32 %i
; CHECK: @null-pointer-is-valid_callee0(i32 %i) ; CHECK: @null-pointer-is-valid_callee0(i32 %i)
; CHECK-NEXT: ret i32 ; CHECK-NEXT: ret i32
} }
define i32 @null-pointer-is-valid_callee1(i32 %i) alwaysinline "null-pointer-is-valid"="true" { define i32 @null-pointer-is-valid_callee1(i32 %i) alwaysinline null_pointer_is_valid {
ret i32 %i ret i32 %i
; CHECK: @null-pointer-is-valid_callee1(i32 %i) ; CHECK: @null-pointer-is-valid_callee1(i32 %i)
; CHECK-NEXT: ret i32 ; CHECK-NEXT: ret i32
} }
define i32 @null-pointer-is-valid_callee2(i32 %i) { define i32 @null-pointer-is-valid_callee2(i32 %i) {
ret i32 %i ret i32 %i
; CHECK: @null-pointer-is-valid_callee2(i32 %i) ; CHECK: @null-pointer-is-valid_callee2(i32 %i)
; CHECK-NEXT: ret i32 ; CHECK-NEXT: ret i32
} }
; No inlining since caller does not have "null-pointer-is-valid"="true" attribute. ; No inlining since caller does not have null_pointer_is_valid attribute.
define i32 @test_null-pointer-is-valid0(i32 %i) { define i32 @test_null-pointer-is-valid0(i32 %i) {
%1 = call i32 @null-pointer-is-valid_callee0(i32 %i) %1 = call i32 @null-pointer-is-valid_callee0(i32 %i)
ret i32 %1 ret i32 %1
; CHECK: @test_null-pointer-is-valid0( ; CHECK: @test_null-pointer-is-valid0(
; CHECK: call i32 @null-pointer-is-valid_callee0 ; CHECK: call i32 @null-pointer-is-valid_callee0
; CHECK-NEXT: ret i32 ; CHECK-NEXT: ret i32
} }
; alwaysinline should force inlining even when caller does not have ; alwaysinline should force inlining even when caller does not have
; "null-pointer-is-valid"="true" attribute. However, the attribute should be ; null_pointer_is_valid attribute. However, the attribute should be
; copied to caller. ; copied to caller.
define i32 @test_null-pointer-is-valid1(i32 %i) "null-pointer-is-valid"="false" { define i32 @test_null-pointer-is-valid1(i32 %i) {
%1 = call i32 @null-pointer-is-valid_callee1(i32 %i) %1 = call i32 @null-pointer-is-valid_callee1(i32 %i)
ret i32 %1 ret i32 %1
; CHECK: @test_null-pointer-is-valid1(i32 %i) [[NULLPOINTERISVALID:#[0-9]+]] { ; CHECK: @test_null-pointer-is-valid1(i32 %i) [[NULLPOINTERISVALID:#[0-9]+]] {
; CHECK-NEXT: ret i32 ; CHECK-NEXT: ret i32
} }
; Can inline since both caller and callee have "null-pointer-is-valid"="true" ; Can inline since both caller and callee have null_pointer_is_valid
; attribute. ; attribute.
define i32 @test_null-pointer-is-valid2(i32 %i) "null-pointer-is-valid"="true" { define i32 @test_null-pointer-is-valid2(i32 %i) null_pointer_is_valid {
%1 = call i32 @null-pointer-is-valid_callee2(i32 %i) %1 = call i32 @null-pointer-is-valid_callee2(i32 %i)
ret i32 %1 ret i32 %1
; CHECK: @test_null-pointer-is-valid2(i32 %i) [[NULLPOINTERISVALID]] { ; CHECK: @test_null-pointer-is-valid2(i32 %i) [[NULLPOINTERISVALID]] {
; CHECK-NEXT: ret i32 ; CHECK-NEXT: ret i32
} }
; CHECK: attributes [[SLH]] = { speculative_load_hardening } ; CHECK: attributes [[SLH]] = { speculative_load_hardening }
; CHECK: attributes [[FPMAD_FALSE]] = { "less-precise-fpmad"="false" } ; CHECK: attributes [[FPMAD_FALSE]] = { "less-precise-fpmad"="false" }
; CHECK: attributes [[FPMAD_TRUE]] = { "less-precise-fpmad"="true" } ; CHECK: attributes [[FPMAD_TRUE]] = { "less-precise-fpmad"="true" }
; CHECK: attributes [[NOIMPLICITFLOAT]] = { noimplicitfloat } ; CHECK: attributes [[NOIMPLICITFLOAT]] = { noimplicitfloat }
; CHECK: attributes [[NOUSEJUMPTABLES]] = { "no-jump-tables"="true" } ; CHECK: attributes [[NOUSEJUMPTABLES]] = { "no-jump-tables"="true" }
; CHECK: attributes [[NULLPOINTERISVALID]] = { "null-pointer-is-valid"="true" } ; CHECK: attributes [[NULLPOINTERISVALID]] = { null_pointer_is_valid }

llvm/test/Transforms/InstCombine/atomic.ll

Show First 20 Lines • Show All 324 Lines • ▼ Show 20 Lines
; CHECK-LABEL: @no_atomic_vector_store ; CHECK-LABEL: @no_atomic_vector_store
; CHECK: store atomic i64 %1, i64* %2 unordered, align 8 ; CHECK: store atomic i64 %1, i64* %2 unordered, align 8
%1 = bitcast <2 x float> %p to i64 %1 = bitcast <2 x float> %p to i64
%2 = bitcast i8* %p2 to i64* %2 = bitcast i8* %p2 to i64*
store atomic i64 %1, i64* %2 unordered, align 8 store atomic i64 %1, i64* %2 unordered, align 8
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/InstCombine/invariant.group.ll

Show First 20 Lines • Show All 141 Lines • ▼ Show 20 Lines
declare i8* @llvm.launder.invariant.group.p0i8(i8*) declare i8* @llvm.launder.invariant.group.p0i8(i8*)
declare i8 addrspace(42)* @llvm.launder.invariant.group.p42i8(i8 addrspace(42)*) declare i8 addrspace(42)* @llvm.launder.invariant.group.p42i8(i8 addrspace(42)*)
declare i8* @llvm.strip.invariant.group.p0i8(i8*) declare i8* @llvm.strip.invariant.group.p0i8(i8*)
declare i8 addrspace(42)* @llvm.strip.invariant.group.p42i8(i8 addrspace(42)*) declare i8 addrspace(42)* @llvm.strip.invariant.group.p42i8(i8 addrspace(42)*)
declare i16* @llvm.strip.invariant.group.p0i16(i16* %c1) declare i16* @llvm.strip.invariant.group.p0i16(i16* %c1)
declare i16 addrspace(42)* @llvm.strip.invariant.group.p42i16(i16 addrspace(42)* %c1) declare i16 addrspace(42)* @llvm.strip.invariant.group.p42i16(i16 addrspace(42)* %c1)
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/InstCombine/invoke.ll

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
lpad: lpad:
%1 = landingpad { i8*, i32 } %1 = landingpad { i8*, i32 }
filter [0 x i8*] zeroinitializer filter [0 x i8*] zeroinitializer
%2 = extractvalue { i8*, i32 } %1, 0 %2 = extractvalue { i8*, i32 } %1, 0
tail call void @__cxa_call_unexpected(i8* %2) noreturn nounwind tail call void @__cxa_call_unexpected(i8* %2) noreturn nounwind
unreachable unreachable
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }
; CHECK-LABEL: @f3( ; CHECK-LABEL: @f3(
define void @f3() nounwind uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { define void @f3() nounwind uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
; CHECK: invoke void @llvm.donothing() ; CHECK: invoke void @llvm.donothing()
%call = invoke noalias i8* @_Znwm(i64 13) %call = invoke noalias i8* @_Znwm(i64 13)
to label %invoke.cont unwind label %lpad to label %invoke.cont unwind label %lpad
invoke.cont: invoke.cont:
Show All 9 Lines

llvm/test/Transforms/InstCombine/lifetime-no-null-opt.ll

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lineselse:
call void @llvm.lifetime.end.p0i8(i64 1, i8* %1) call void @llvm.lifetime.end.p0i8(i64 1, i8* %1)
call void @llvm.lifetime.end.p0i8(i64 1, i8* %0) call void @llvm.lifetime.end.p0i8(i64 1, i8* %0)
br label %fin br label %fin
fin: fin:
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }
!llvm.dbg.cu = !{!0} !llvm.dbg.cu = !{!0}
!llvm.module.flags = !{!22, !23} !llvm.module.flags = !{!22, !23}
!llvm.ident = !{!24} !llvm.ident = !{!24}
!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.8.0 (trunk 248826) (llvm/trunk 248827)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2) !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.8.0 (trunk 248826) (llvm/trunk 248827)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
!1 = !DIFile(filename: "test.cpp", directory: "/home/user") !1 = !DIFile(filename: "test.cpp", directory: "/home/user")
!2 = !{} !2 = !{}
Show All 23 Lines

llvm/test/Transforms/InstCombine/load.ll

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[V:%.*]] = getelementptr i32, i32* null, i64 [[TMP1]] ; CHECK-NEXT: [[V:%.*]] = getelementptr i32, i32* null, i64 [[TMP1]]
; CHECK-NEXT: [[R:%.*]] = load i32, i32* [[V]], align 4 ; CHECK-NEXT: [[R:%.*]] = load i32, i32* [[V]], align 4
; CHECK-NEXT: ret i32 [[R]] ; CHECK-NEXT: ret i32 [[R]]
; ;
%V = getelementptr i32, i32* null, i32 %X ; <i32*> [#uses=1] %V = getelementptr i32, i32* null, i32 %X ; <i32*> [#uses=1]
%R = load i32, i32* %V ; <i32> [#uses=1] %R = load i32, i32* %V ; <i32> [#uses=1]
ret i32 %R ret i32 %R
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }
define i32 @test8(i32* %P) { define i32 @test8(i32* %P) {
; CHECK-LABEL: @test8( ; CHECK-LABEL: @test8(
; CHECK-NEXT: store i32 1, i32* [[P:%.*]], align 4 ; CHECK-NEXT: store i32 1, i32* [[P:%.*]], align 4
; CHECK-NEXT: ret i32 1 ; CHECK-NEXT: ret i32 1
; ;
store i32 1, i32* %P store i32 1, i32* %P
%X = load i32, i32* %P ; <i32> [#uses=1] %X = load i32, i32* %P ; <i32> [#uses=1]
▲ Show 20 Lines • Show All 261 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/mem-deref-bytes.ll

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
; CHECK-LABEL: @memcmp_const_size_update_deref4( ; CHECK-LABEL: @memcmp_const_size_update_deref4(
; CHECK-NEXT: [[CALL:%.*]] = tail call i32 @memcmp(i8* nonnull dereferenceable(16) [[D:%.*]], i8* nonnull dereferenceable(16) [[S:%.*]], i64 16) ; CHECK-NEXT: [[CALL:%.*]] = tail call i32 @memcmp(i8* nonnull dereferenceable(16) [[D:%.*]], i8* nonnull dereferenceable(16) [[S:%.*]], i64 16)
; CHECK-NEXT: ret i32 [[CALL]] ; CHECK-NEXT: ret i32 [[CALL]]
; ;
%call = tail call i32 @memcmp(i8* dereferenceable_or_null(16) %d, i8* %s, i64 16) %call = tail call i32 @memcmp(i8* dereferenceable_or_null(16) %d, i8* %s, i64 16)
ret i32 %call ret i32 %call
} }
define i32 @memcmp_const_size_update_deref5(i8* nocapture readonly %d, i8* nocapture readonly %s) "null-pointer-is-valid"="false" { define i32 @memcmp_const_size_update_deref5(i8* nocapture readonly %d, i8* nocapture readonly %s) {
; CHECK-LABEL: @memcmp_const_size_update_deref5( ; CHECK-LABEL: @memcmp_const_size_update_deref5(
; CHECK-NEXT: [[CALL:%.*]] = tail call i32 @memcmp(i8* nonnull dereferenceable(40) [[D:%.*]], i8* nonnull dereferenceable(16) [[S:%.*]], i64 16) ; CHECK-NEXT: [[CALL:%.*]] = tail call i32 @memcmp(i8* nonnull dereferenceable(40) [[D:%.*]], i8* nonnull dereferenceable(16) [[S:%.*]], i64 16)
; CHECK-NEXT: ret i32 [[CALL]] ; CHECK-NEXT: ret i32 [[CALL]]
; ;
%call = tail call i32 @memcmp(i8* dereferenceable_or_null(40) %d, i8* %s, i64 16) %call = tail call i32 @memcmp(i8* dereferenceable_or_null(40) %d, i8* %s, i64 16)
ret i32 %call ret i32 %call
} }
define i32 @memcmp_const_size_update_deref6(i8* nocapture readonly %d, i8* nocapture readonly %s) "null-pointer-is-valid"="true" { define i32 @memcmp_const_size_update_deref6(i8* nocapture readonly %d, i8* nocapture readonly %s) null_pointer_is_valid {
; CHECK-LABEL: @memcmp_const_size_update_deref6( ; CHECK-LABEL: @memcmp_const_size_update_deref6(
; CHECK-NEXT: [[CALL:%.*]] = tail call i32 @memcmp(i8* dereferenceable(16) dereferenceable_or_null(40) [[D:%.*]], i8* dereferenceable(16) [[S:%.*]], i64 16) ; CHECK-NEXT: [[CALL:%.*]] = tail call i32 @memcmp(i8* dereferenceable(16) dereferenceable_or_null(40) [[D:%.*]], i8* dereferenceable(16) [[S:%.*]], i64 16)
; CHECK-NEXT: ret i32 [[CALL]] ; CHECK-NEXT: ret i32 [[CALL]]
; ;
%call = tail call i32 @memcmp(i8* dereferenceable_or_null(40) %d, i8* %s, i64 16) %call = tail call i32 @memcmp(i8* dereferenceable_or_null(40) %d, i8* %s, i64 16)
ret i32 %call ret i32 %call
} }
define i32 @memcmp_const_size_update_deref7(i8* nocapture readonly %d, i8* nocapture readonly %s) "null-pointer-is-valid"="true" { define i32 @memcmp_const_size_update_deref7(i8* nocapture readonly %d, i8* nocapture readonly %s) null_pointer_is_valid {
; CHECK-LABEL: @memcmp_const_size_update_deref7( ; CHECK-LABEL: @memcmp_const_size_update_deref7(
; CHECK-NEXT: [[CALL:%.*]] = tail call i32 @memcmp(i8* nonnull dereferenceable(40) [[D:%.*]], i8* dereferenceable(16) [[S:%.*]], i64 16) ; CHECK-NEXT: [[CALL:%.*]] = tail call i32 @memcmp(i8* nonnull dereferenceable(40) [[D:%.*]], i8* dereferenceable(16) [[S:%.*]], i64 16)
; CHECK-NEXT: ret i32 [[CALL]] ; CHECK-NEXT: ret i32 [[CALL]]
; ;
%call = tail call i32 @memcmp(i8* nonnull dereferenceable_or_null(40) %d, i8* %s, i64 16) %call = tail call i32 @memcmp(i8* nonnull dereferenceable_or_null(40) %d, i8* %s, i64 16)
ret i32 %call ret i32 %call
} }
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/memchr.ll

Show First 20 Lines • Show All 227 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[RET:%.*]] = call i8* @memchr(i8* nonnull dereferenceable(5) [[STR:%.*]], i32 [[C:%.*]], i32 5) ; CHECK-NEXT: [[RET:%.*]] = call i8* @memchr(i8* nonnull dereferenceable(5) [[STR:%.*]], i32 [[C:%.*]], i32 5)
; CHECK-NEXT: ret i8* [[RET]] ; CHECK-NEXT: ret i8* [[RET]]
; ;
%ret = call i8* @memchr(i8* %str, i32 %c, i32 5) %ret = call i8* @memchr(i8* %str, i32 %c, i32 5)
ret i8* %ret ret i8* %ret
} }
define i8* @test19(i8* %str, i32 %c) "null-pointer-is-valid"="true" { define i8* @test19(i8* %str, i32 %c) null_pointer_is_valid {
; CHECK-LABEL: @test19( ; CHECK-LABEL: @test19(
; CHECK-NEXT: [[RET:%.*]] = call i8* @memchr(i8* dereferenceable(5) [[STR:%.*]], i32 [[C:%.*]], i32 5) ; CHECK-NEXT: [[RET:%.*]] = call i8* @memchr(i8* dereferenceable(5) [[STR:%.*]], i32 [[C:%.*]], i32 5)
; CHECK-NEXT: ret i8* [[RET]] ; CHECK-NEXT: ret i8* [[RET]]
; ;
%ret = call i8* @memchr(i8* %str, i32 %c, i32 5) %ret = call i8* @memchr(i8* %str, i32 %c, i32 5)
ret i8* %ret ret i8* %ret
} }

llvm/test/Transforms/InstCombine/memcpy-addrspace.ll

Show First 20 Lines • Show All 116 Lines • ▼ Show 20 Linesentry:
%arrayidx2 = getelementptr inbounds i32, i32 addrspace(1)* %out, i64 %y %arrayidx2 = getelementptr inbounds i32, i32 addrspace(1)* %out, i64 %y
store i32 %2, i32 addrspace(1)* %arrayidx2, align 4 store i32 %2, i32 addrspace(1)* %arrayidx2, align 4
ret void ret void
} }
declare void @llvm.memcpy.p0i8.p2i8.i64(i8* nocapture writeonly, i8 addrspace(2)* nocapture readonly, i64, i1) declare void @llvm.memcpy.p0i8.p2i8.i64(i8* nocapture writeonly, i8 addrspace(2)* nocapture readonly, i64, i1)
declare i32 @foo(i32* %x) declare i32 @foo(i32* %x)
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/InstCombine/memcpy-from-global.ll

Show First 20 Lines • Show All 317 Lines • ▼ Show 20 Linesentry:
%cc = alloca [3 x i8], align 1 %cc = alloca [3 x i8], align 1
%cc.0..sroa_idx = getelementptr inbounds [3 x i8], [3 x i8]* %cc, i64 0, i64 0 %cc.0..sroa_idx = getelementptr inbounds [3 x i8], [3 x i8]* %cc, i64 0, i64 0
%arraydecay = getelementptr inbounds [3 x i8], [3 x i8]* %cc, i32 0, i32 0 %arraydecay = getelementptr inbounds [3 x i8], [3 x i8]* %cc, i32 0, i32 0
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %arraydecay, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZL3KKK, i32 0, i32 0), i64 3, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %arraydecay, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZL3KKK, i32 0, i32 0), i64 3, i1 false)
call void @llvm.memcpy.p0i8.p0i8.i64(i8* getelementptr inbounds ([1000000 x i8], [1000000 x i8]* @bbb, i32 0, i32 0), i8* %arraydecay, i64 3, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* getelementptr inbounds ([1000000 x i8], [1000000 x i8]* @bbb, i32 0, i32 0), i8* %arraydecay, i64 3, i1 false)
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/InstCombine/memrchr.ll

Show All 28 Lines
; CHECK-NEXT: [[RET:%.*]] = call i8* @memrchr(i8* [[STR:%.*]], i32 [[C:%.*]], i32 5) ; CHECK-NEXT: [[RET:%.*]] = call i8* @memrchr(i8* [[STR:%.*]], i32 [[C:%.*]], i32 5)
; CHECK-NEXT: ret i8* [[RET]] ; CHECK-NEXT: ret i8* [[RET]]
; ;
%ret = call i8* @memrchr(i8* %str, i32 %c, i32 5) %ret = call i8* @memrchr(i8* %str, i32 %c, i32 5)
ret i8* %ret ret i8* %ret
} }
define i8* @test4(i8* %str, i32 %c) "null-pointer-is-valid"="true" { define i8* @test4(i8* %str, i32 %c) null_pointer_is_valid {
; CHECK-LABEL: @test4( ; CHECK-LABEL: @test4(
; CHECK-NEXT: [[RET:%.*]] = call i8* @memrchr(i8* [[STR:%.*]], i32 [[C:%.*]], i32 5) ; CHECK-NEXT: [[RET:%.*]] = call i8* @memrchr(i8* [[STR:%.*]], i32 [[C:%.*]], i32 5)
; CHECK-NEXT: ret i8* [[RET]] ; CHECK-NEXT: ret i8* [[RET]]
; ;
%ret = call i8* @memrchr(i8* %str, i32 %c, i32 5) %ret = call i8* @memrchr(i8* %str, i32 %c, i32 5)
ret i8* %ret ret i8* %ret
} }
Show All 10 Lines

llvm/test/Transforms/InstCombine/select.ll

Show First 20 Lines • Show All 369 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[V:%.*]] = load i32, i32* [[P2]], align 4 ; CHECK-NEXT: [[V:%.*]] = load i32, i32* [[P2]], align 4
; CHECK-NEXT: ret i32 [[V]] ; CHECK-NEXT: ret i32 [[V]]
; ;
%P2 = select i1 %C, i32* null, i32* %P %P2 = select i1 %C, i32* null, i32* %P
%V = load i32, i32* %P2 %V = load i32, i32* %P2
ret i32 %V ret i32 %V
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }
define i1 @test17(i32* %X, i1 %C) { define i1 @test17(i32* %X, i1 %C) {
; CHECK-LABEL: @test17( ; CHECK-LABEL: @test17(
; CHECK-NEXT: [[RV1:%.*]] = icmp eq i32* [[X:%.*]], null ; CHECK-NEXT: [[RV1:%.*]] = icmp eq i32* [[X:%.*]], null
; CHECK-NEXT: [[NOT_C:%.*]] = xor i1 [[C:%.*]], true ; CHECK-NEXT: [[NOT_C:%.*]] = xor i1 [[C:%.*]], true
; CHECK-NEXT: [[RV:%.*]] = or i1 [[RV1]], [[NOT_C]] ; CHECK-NEXT: [[RV:%.*]] = or i1 [[RV1]], [[NOT_C]]
; CHECK-NEXT: ret i1 [[RV]] ; CHECK-NEXT: ret i1 [[RV]]
; ;
▲ Show 20 Lines • Show All 1,285 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/store.ll

Show All 39 Lines
; CHECK-NEXT: store i32 24, i32* [[PTR]], align 4 ; CHECK-NEXT: store i32 24, i32* [[PTR]], align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%ptr = getelementptr i32, i32 *null, i64 %offset %ptr = getelementptr i32, i32 *null, i64 %offset
store i32 24, i32* %ptr store i32 24, i32* %ptr
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }
;; Simple sinking tests ;; Simple sinking tests
; "if then else" ; "if then else"
define i32 @test3(i1 %C) { define i32 @test3(i1 %C) {
; CHECK-LABEL: @test3( ; CHECK-LABEL: @test3(
; CHECK-NEXT: br i1 [[C:%.*]], label [[COND:%.*]], label [[COND2:%.*]] ; CHECK-NEXT: br i1 [[C:%.*]], label [[COND:%.*]], label [[COND2:%.*]]
; CHECK: Cond: ; CHECK: Cond:
▲ Show 20 Lines • Show All 252 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strchr-1.ll

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[RET:%.*]] = call i8* @strchr(i8* nonnull dereferenceable(1) [[STR:%.*]], i32 [[C:%.*]]) ; CHECK-NEXT: [[RET:%.*]] = call i8* @strchr(i8* nonnull dereferenceable(1) [[STR:%.*]], i32 [[C:%.*]])
; CHECK-NEXT: ret i8* [[RET]] ; CHECK-NEXT: ret i8* [[RET]]
; ;
%ret = call i8* @strchr(i8* %str, i32 %c) %ret = call i8* @strchr(i8* %str, i32 %c)
ret i8* %ret ret i8* %ret
} }
define i8* @test2(i8* %str, i32 %c) "null-pointer-is-valid"="true" { define i8* @test2(i8* %str, i32 %c) null_pointer_is_valid {
; CHECK-LABEL: @test2( ; CHECK-LABEL: @test2(
; CHECK-NEXT: [[RET:%.*]] = call i8* @strchr(i8* [[STR:%.*]], i32 [[C:%.*]]) ; CHECK-NEXT: [[RET:%.*]] = call i8* @strchr(i8* [[STR:%.*]], i32 [[C:%.*]])
; CHECK-NEXT: ret i8* [[RET]] ; CHECK-NEXT: ret i8* [[RET]]
; ;
%ret = call i8* @strchr(i8* %str, i32 %c) %ret = call i8* @strchr(i8* %str, i32 %c)
ret i8* %ret ret i8* %ret
} }

llvm/test/Transforms/InstCombine/strcpy_chk-64.ll

Show All 22 Linesentry:
call void @func2(i8* %arraydecay) call void @func2(i8* %arraydecay)
ret void ret void
} }
declare i8* @__strcpy_chk(i8*, i8*, i64) nounwind declare i8* @__strcpy_chk(i8*, i8*, i64) nounwind
declare void @func2(i8*) declare void @func2(i8*)
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/InstCombine/strlen-1.ll

Show First 20 Lines • Show All 213 Lines • ▼ Show 20 Lines
; CHECK-LABEL: @test2( ; CHECK-LABEL: @test2(
; CHECK-NEXT: [[LEN:%.*]] = tail call i32 @strlen(i8* [[STR:%.*]]) #1 ; CHECK-NEXT: [[LEN:%.*]] = tail call i32 @strlen(i8* [[STR:%.*]]) #1
; CHECK-NEXT: ret i32 [[LEN]] ; CHECK-NEXT: ret i32 [[LEN]]
; ;
%len = tail call i32 @strlen(i8* %str) nounwind %len = tail call i32 @strlen(i8* %str) nounwind
ret i32 %len ret i32 %len
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/InstCombine/strncat-2.ll

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[TEMP1:%.*]] = call i8* @strncat(i8* nonnull dereferenceable(1) [[STR1:%.*]], i8* nonnull dereferenceable(1) [[STR2:%.*]], i32 5) ; CHECK-NEXT: [[TEMP1:%.*]] = call i8* @strncat(i8* nonnull dereferenceable(1) [[STR1:%.*]], i8* nonnull dereferenceable(1) [[STR2:%.*]], i32 5)
; CHECK-NEXT: ret i8* [[TEMP1]] ; CHECK-NEXT: ret i8* [[TEMP1]]
; ;
%temp1 = call i8* @strncat(i8* %str1, i8* %str2, i32 5) %temp1 = call i8* @strncat(i8* %str1, i8* %str2, i32 5)
ret i8* %temp1 ret i8* %temp1
} }
define i8* @test4(i8* %str1, i8* %str2, i32 %n) "null-pointer-is-valid"="true" { define i8* @test4(i8* %str1, i8* %str2, i32 %n) null_pointer_is_valid {
; CHECK-LABEL: @test4( ; CHECK-LABEL: @test4(
; CHECK-NEXT: [[TEMP1:%.*]] = call i8* @strncat(i8* [[STR1:%.*]], i8* [[STR2:%.*]], i32 [[N:%.*]]) ; CHECK-NEXT: [[TEMP1:%.*]] = call i8* @strncat(i8* [[STR1:%.*]], i8* [[STR2:%.*]], i32 [[N:%.*]])
; CHECK-NEXT: ret i8* [[TEMP1]] ; CHECK-NEXT: ret i8* [[TEMP1]]
; ;
%temp1 = call i8* @strncat(i8* %str1, i8* %str2, i32 %n) %temp1 = call i8* @strncat(i8* %str1, i8* %str2, i32 %n)
ret i8* %temp1 ret i8* %temp1
} }
Show All 12 Lines

llvm/test/Transforms/InstCombine/strncmp-1.ll

Show First 20 Lines • Show All 133 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[TEMP1:%.*]] = call i32 @strncmp(i8* nonnull dereferenceable(1) [[STR1:%.*]], i8* nonnull dereferenceable(1) [[STR2:%.*]], i32 5) ; CHECK-NEXT: [[TEMP1:%.*]] = call i32 @strncmp(i8* nonnull dereferenceable(1) [[STR1:%.*]], i8* nonnull dereferenceable(1) [[STR2:%.*]], i32 5)
; CHECK-NEXT: ret i32 [[TEMP1]] ; CHECK-NEXT: ret i32 [[TEMP1]]
; ;
%temp1 = call i32 @strncmp(i8* %str1, i8* %str2, i32 5) %temp1 = call i32 @strncmp(i8* %str1, i8* %str2, i32 5)
ret i32 %temp1 ret i32 %temp1
} }
define i32 @test12(i8* %str1, i8* %str2, i32 %n) "null-pointer-is-valid"="true" { define i32 @test12(i8* %str1, i8* %str2, i32 %n) null_pointer_is_valid {
; CHECK-LABEL: @test12( ; CHECK-LABEL: @test12(
; CHECK-NEXT: [[TEMP1:%.*]] = call i32 @strncmp(i8* [[STR1:%.*]], i8* [[STR2:%.*]], i32 [[N:%.*]]) ; CHECK-NEXT: [[TEMP1:%.*]] = call i32 @strncmp(i8* [[STR1:%.*]], i8* [[STR2:%.*]], i32 [[N:%.*]])
; CHECK-NEXT: ret i32 [[TEMP1]] ; CHECK-NEXT: ret i32 [[TEMP1]]
; ;
%temp1 = call i32 @strncmp(i8* %str1, i8* %str2, i32 %n) %temp1 = call i32 @strncmp(i8* %str1, i8* %str2, i32 %n)
ret i32 %temp1 ret i32 %temp1
} }

llvm/test/Transforms/InstCombine/strrchr-1.ll

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[RET:%.*]] = call i8* @strrchr(i8* nonnull dereferenceable(1) [[STR:%.*]], i32 [[C:%.*]]) ; CHECK-NEXT: [[RET:%.*]] = call i8* @strrchr(i8* nonnull dereferenceable(1) [[STR:%.*]], i32 [[C:%.*]])
; CHECK-NEXT: ret i8* [[RET]] ; CHECK-NEXT: ret i8* [[RET]]
; ;
%ret = call i8* @strrchr(i8* %str, i32 %c) %ret = call i8* @strrchr(i8* %str, i32 %c)
ret i8* %ret ret i8* %ret
} }
define i8* @test2(i8* %str, i32 %c) "null-pointer-is-valid"="true" { define i8* @test2(i8* %str, i32 %c) null_pointer_is_valid {
; CHECK-LABEL: @test2( ; CHECK-LABEL: @test2(
; CHECK-NEXT: [[RET:%.*]] = call i8* @strrchr(i8* [[STR:%.*]], i32 [[C:%.*]]) ; CHECK-NEXT: [[RET:%.*]] = call i8* @strrchr(i8* [[STR:%.*]], i32 [[C:%.*]])
; CHECK-NEXT: ret i8* [[RET]] ; CHECK-NEXT: ret i8* [[RET]]
; ;
%ret = call i8* @strrchr(i8* %str, i32 %c) %ret = call i8* @strrchr(i8* %str, i32 %c)
ret i8* %ret ret i8* %ret
} }

llvm/test/Transforms/InstCombine/strstr-1.ll

Show First 20 Lines • Show All 74 Lines • ▼ Show 20 Lines
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[RET:%.*]] = call i8* @strstr(i8* nonnull dereferenceable(1) [[STR1:%.*]], i8* nonnull dereferenceable(1) [[STR2:%.*]]) ; CHECK-NEXT: [[RET:%.*]] = call i8* @strstr(i8* nonnull dereferenceable(1) [[STR1:%.*]], i8* nonnull dereferenceable(1) [[STR2:%.*]])
; CHECK-NEXT: ret i8* [[RET]] ; CHECK-NEXT: ret i8* [[RET]]
; ;
%ret = call i8* @strstr(i8* %str1, i8* %str2) %ret = call i8* @strstr(i8* %str1, i8* %str2)
ret i8* %ret ret i8* %ret
} }
define i8* @test2(i8* %str1, i8* %str2) "null-pointer-is-valid"="true" { define i8* @test2(i8* %str1, i8* %str2) null_pointer_is_valid {
; CHECK-LABEL: @test2( ; CHECK-LABEL: @test2(
; CHECK-NEXT: [[RET:%.*]] = call i8* @strstr(i8* [[STR1:%.*]], i8* [[STR2:%.*]]) ; CHECK-NEXT: [[RET:%.*]] = call i8* @strstr(i8* [[STR1:%.*]], i8* [[STR2:%.*]])
; CHECK-NEXT: ret i8* [[RET]] ; CHECK-NEXT: ret i8* [[RET]]
; ;
%ret = call i8* @strstr(i8* %str1, i8* %str2) %ret = call i8* @strstr(i8* %str1, i8* %str2)
ret i8* %ret ret i8* %ret
} }

llvm/test/Transforms/InstCombine/wcslen-1.ll

Show First 20 Lines • Show All 213 Lines • ▼ Show 20 Lines
; CHECK-LABEL: @test_no_simplify4( ; CHECK-LABEL: @test_no_simplify4(
; CHECK-NEXT: [[L:%.*]] = call i64 @wcslen(i32* bitcast ([1 x i16]* @str16 to i32*)) ; CHECK-NEXT: [[L:%.*]] = call i64 @wcslen(i32* bitcast ([1 x i16]* @str16 to i32*))
; CHECK-NEXT: ret i64 [[L]] ; CHECK-NEXT: ret i64 [[L]]
; ;
%l = call i64 @wcslen(i32* bitcast ([1 x i16]* @str16 to i32*)) %l = call i64 @wcslen(i32* bitcast ([1 x i16]* @str16 to i32*))
ret i64 %l ret i64 %l
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/InstSimplify/compare.ll

Show First 20 Lines • Show All 1,667 Lines • ▼ Show 20 Lines
; CHECK-NEXT: ret i1 true ; CHECK-NEXT: ret i1 true
; ;
%p0 = addrspacecast i32 addrspace(1)* %p1 to i32* %p0 = addrspacecast i32 addrspace(1)* %p1 to i32*
%p0.1 = getelementptr inbounds i32, i32* %p0, i64 1 %p0.1 = getelementptr inbounds i32, i32* %p0, i64 1
%cmp = icmp ne i32* %p0, %p0.1 %cmp = icmp ne i32* %p0, %p0.1
ret i1 %cmp ret i1 %cmp
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/LoopIdiom/pr28196.ll

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
; CHECK-LABEL: define void @test1_no_null_opt( ; CHECK-LABEL: define void @test1_no_null_opt(
; CHECK-NOT: call void @llvm.memcpy ; CHECK-NOT: call void @llvm.memcpy
; CHECK: getelementptr ; CHECK: getelementptr
; CHECK: getelementptr ; CHECK: getelementptr
; CHECK: load ; CHECK: load
; CHECK: store ; CHECK: store
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/LoopVersioning/lcssa.ll

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Linesbb3.loopexit:
store i8 %_tmp15.lcssa, i8* %cse3.22 store i8 %_tmp15.lcssa, i8* %cse3.22
store i8* %_tmp30.lcssa, i8** %ls2.21 store i8* %_tmp30.lcssa, i8** %ls2.21
br label %bb3 br label %bb3
bb3: bb3:
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/SimplifyCFG/UnreachableEliminate.ll

Show First 20 Lines • Show All 200 Lines • ▼ Show 20 Linesif:
br label %else br label %else
else: else:
%phi = phi void ()* [ %Y, %entry ], [ null, %if ] %phi = phi void ()* [ %Y, %entry ], [ null, %if ]
call void %phi() call void %phi()
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/SimplifyCFG/invoke.ll

Show First 20 Lines • Show All 153 Lines • ▼ Show 20 Lines
lpad: lpad:
; CHECK-NOT: phi ; CHECK-NOT: phi
%tmp = phi i8* [ null, %invoke.cont1 ], [ null, %entry ] %tmp = phi i8* [ null, %invoke.cont1 ], [ null, %entry ]
landingpad { i8*, i32 } landingpad { i8*, i32 }
cleanup cleanup
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/SimplifyCFG/phi-undef-loadstore.ll

Show First 20 Lines • Show All 230 Lines • ▼ Show 20 Lines
; CHECK-LABEL: @test4_no_null_opt( ; CHECK-LABEL: @test4_no_null_opt(
; CHECK: if.then: ; CHECK: if.then:
; CHECK: if.else: ; CHECK: if.else:
; CHECK: if.then4: ; CHECK: if.then4:
; CHECK: if.end7: ; CHECK: if.end7:
; CHECK-NEXT: phi i32* [ %a, %if.then ], [ null, %if.then4 ], [ null, %if.else ] ; CHECK-NEXT: phi i32* [ %a, %if.then ], [ null, %if.then4 ], [ null, %if.else ]
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/SimplifyCFG/trap-no-null-opt-debugloc.ll

; RUN: opt -S -simplifycfg < %s | FileCheck %s ; RUN: opt -S -simplifycfg < %s | FileCheck %s
define void @foo() nounwind ssp #0 !dbg !0 { define void @foo() nounwind ssp #0 !dbg !0 {
; CHECK: store i32 42, i32* null ; CHECK: store i32 42, i32* null
; CHECK-NOT: call void @llvm.trap() ; CHECK-NOT: call void @llvm.trap()
; CHECK: ret void ; CHECK: ret void
store i32 42, i32* null, !dbg !5 store i32 42, i32* null, !dbg !5
ret void, !dbg !7 ret void, !dbg !7
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }
!llvm.dbg.cu = !{!2} !llvm.dbg.cu = !{!2}
!llvm.module.flags = !{!10} !llvm.module.flags = !{!10}
!0 = distinct !DISubprogram(name: "foo", line: 3, isLocal: false, isDefinition: true, virtualIndex: 6, isOptimized: false, unit: !2, file: !8, scope: !1, type: !3) !0 = distinct !DISubprogram(name: "foo", line: 3, isLocal: false, isDefinition: true, virtualIndex: 6, isOptimized: false, unit: !2, file: !8, scope: !1, type: !3)
!1 = !DIFile(filename: "foo.c", directory: "/private/tmp") !1 = !DIFile(filename: "foo.c", directory: "/private/tmp")
!2 = distinct !DICompileUnit(language: DW_LANG_C99, producer: "Apple clang version 3.0 (tags/Apple/clang-206.1) (based on LLVM 3.0svn)", isOptimized: true, emissionKind: FullDebug, file: !8, enums: !{}, retainedTypes: !{}) !2 = distinct !DICompileUnit(language: DW_LANG_C99, producer: "Apple clang version 3.0 (tags/Apple/clang-206.1) (based on LLVM 3.0svn)", isOptimized: true, emissionKind: FullDebug, file: !8, enums: !{}, retainedTypes: !{})
!3 = !DISubroutineType(types: !4) !3 = !DISubroutineType(types: !4)
!4 = !{null} !4 = !{null}
!5 = !DILocation(line: 4, column: 2, scope: !6) !5 = !DILocation(line: 4, column: 2, scope: !6)
!6 = distinct !DILexicalBlock(line: 3, column: 12, file: !8, scope: !0) !6 = distinct !DILexicalBlock(line: 3, column: 12, file: !8, scope: !0)
!7 = !DILocation(line: 5, column: 1, scope: !6) !7 = !DILocation(line: 5, column: 1, scope: !6)
!8 = !DIFile(filename: "foo.c", directory: "/private/tmp") !8 = !DIFile(filename: "foo.c", directory: "/private/tmp")
!10 = !{i32 1, !"Debug Info Version", i32 3} !10 = !{i32 1, !"Debug Info Version", i32 3}

llvm/test/Transforms/SimplifyCFG/trapping-load-unreachable.ll

Show First 20 Lines • Show All 116 Lines • ▼ Show 20 Linesentry:
br i1 %C, label %T, label %F br i1 %C, label %T, label %F
T: T:
atomicrmw volatile xchg i32* %P, i32 0 seq_cst atomicrmw volatile xchg i32* %P, i32 0 seq_cst
unreachable unreachable
F: F:
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/Util/assume-builder.ll

Show First 20 Lines • Show All 380 Lines • ▼ Show 20 Lines;
%24 = load %struct.S*, %struct.S** %4, align 8 %24 = load %struct.S*, %struct.S** %4, align 8
%25 = getelementptr inbounds %struct.S, %struct.S* %24, i32 0, i32 2 %25 = getelementptr inbounds %struct.S, %struct.S* %24, i32 0, i32 2
%26 = load i32*, i32** %25, align 8 %26 = load i32*, i32** %25, align 8
%27 = load i32, i32* %26, align 4 %27 = load i32, i32* %26, align 4
%28 = add nsw i32 %23, %27 %28 = add nsw i32 %23, %27
ret i32 %28 ret i32 %28
} }
define i32 @test3(%struct.S* %0, i32* %1, i8* %2) "null-pointer-is-valid"="true" { define i32 @test3(%struct.S* %0, i32* %1, i8* %2) null_pointer_is_valid {
; BASIC-LABEL: define {{[^@]+}}@test3 ; BASIC-LABEL: define {{[^@]+}}@test3
; BASIC-SAME: (%struct.S* [[TMP0:%.*]], i32* [[TMP1:%.*]], i8* [[TMP2:%.*]]) #4 ; BASIC-SAME: (%struct.S* [[TMP0:%.*]], i32* [[TMP1:%.*]], i8* [[TMP2:%.*]]) #4
; BASIC-NEXT: [[TMP4:%.*]] = alloca %struct.S*, align 8 ; BASIC-NEXT: [[TMP4:%.*]] = alloca %struct.S*, align 8
; BASIC-NEXT: [[TMP5:%.*]] = alloca i32*, align 8 ; BASIC-NEXT: [[TMP5:%.*]] = alloca i32*, align 8
; BASIC-NEXT: [[TMP6:%.*]] = alloca i8*, align 8 ; BASIC-NEXT: [[TMP6:%.*]] = alloca i8*, align 8
; BASIC-NEXT: [[TMP7:%.*]] = alloca [[STRUCT_S:%.*]], align 8 ; BASIC-NEXT: [[TMP7:%.*]] = alloca [[STRUCT_S:%.*]], align 8
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(%struct.S** [[TMP4]], i64 8), "align"(%struct.S** [[TMP4]], i64 8) ] ; BASIC-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(%struct.S** [[TMP4]], i64 8), "align"(%struct.S** [[TMP4]], i64 8) ]
; BASIC-NEXT: store %struct.S* [[TMP0]], %struct.S** [[TMP4]], align 8 ; BASIC-NEXT: store %struct.S* [[TMP0]], %struct.S** [[TMP4]], align 8
▲ Show 20 Lines • Show All 584 Lines • Show Last 20 Lines

mlir/test/Target/llvmir.mlir

Show First 20 Lines • Show All 1,199 Lines • ▼ Show 20 Linesllvm.func @callFenceInst() {
llvm.fence release llvm.fence release
// CHECK: fence release // CHECK: fence release
llvm.fence syncscope("") release llvm.fence syncscope("") release
llvm.return llvm.return
} }
// CHECK-LABEL: @passthrough // CHECK-LABEL: @passthrough
// CHECK: #[[ATTR_GROUP:[0-9]*]] // CHECK: #[[ATTR_GROUP:[0-9]*]]
llvm.func @passthrough() attributes {passthrough = ["noinline", ["alignstack", "4"], "null-pointer-is-valid", ["foo", "bar"]]} { llvm.func @passthrough() attributes {passthrough = ["noinline", ["alignstack", "4"], "null_pointer_is_valid", ["foo", "bar"]]} {
llvm.return llvm.return
} }
// CHECK: attributes #[[ATTR_GROUP]] = { // CHECK: attributes #[[ATTR_GROUP]] = {
// CHECK-DAG: noinline // CHECK-DAG: noinline
// CHECK-DAG: alignstack=4 // CHECK-DAG: alignstack=4
// CHECK-DAG: "null-pointer-is-valid" // CHECK-DAG: null_pointer_is_valid
// CHECK-DAG: "foo"="bar" // CHECK-DAG: "foo"="bar"