This is an archive of the discontinued LLVM Phabricator instance.

Differential D90896

[Clang][Driver] default to nossp
AbandonedPublic

Authored by nickdesaulniers on Nov 5 2020, 5:33 PM.

Details

Reviewers
void
rnk
Summary

This patch does 2 things:

  1. the default value of StackProtectorMode, StackProtectorMode::SSPOff now explicitly adds the nossp LLVM IR fn attr.
  2. it makes -fno-stack-protector/\GS_ now explictly pass -stack-protector 0 to cc1, which sets the StackProtectorMode to StackProtectorMode::SSPOff.

This allows safer mixing of translation units compiled with
-fno-stack-protector and -fstack-protector* for LTO, since LLVM IR fn
attr nossp will prevent inlining across the two.

Fixes pr/47479.

Alternative to D90194+D90348.

Diff Detail

Unit TestsFailed

TimeTest
40 mslinux > Clang.Driver::cl-options.cu
410 mslinux > HWAddressSanitizer-x86_64.TestCases::sizes.cpp

Revision Contents

PathSize
clang/
lib/
CodeGen/
3 lines
Driver/
ToolChains/
8 lines
test/
CXX/
special/
class.dtor/
2 lines
CodeGen/
2 lines
60 lines
14 lines
2 lines
4 lines
2 lines
18 lines
18 lines
18 lines
24 lines
4 lines
4 lines
2 lines
10 lines
2 lines
8 lines
4 lines
4 lines
4 lines
2 lines
6 lines
2 lines
2 lines
2 lines
4 lines
8 lines
2 lines
4 lines
6 lines
2 lines
CodeGenCXX/
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
CodeGenObjC/
2 lines
2 lines
CodeGenObjCXX/
4 lines
CodeGenOpenCL/
2 lines
Driver/
2 lines
PCH/
2 lines
utils/
update_cc_test_checks/
Inputs/
2 lines

Diff 303309

clang/lib/CodeGen/CodeGenModule.cpp

Show First 20 Lines • Show All 1,636 Lines • ▼ Show 20 Lines if (CodeGenOpts.UnwindTables)
B.addAttribute(llvm::Attribute::UWTable); B.addAttribute(llvm::Attribute::UWTable);
if (CodeGenOpts.StackClashProtector) if (CodeGenOpts.StackClashProtector)
B.addAttribute("probe-stack", "inline-asm"); B.addAttribute("probe-stack", "inline-asm");
if (!hasUnwindExceptions(LangOpts)) if (!hasUnwindExceptions(LangOpts))
B.addAttribute(llvm::Attribute::NoUnwind); B.addAttribute(llvm::Attribute::NoUnwind);
if (D && D->hasAttr<NoStackProtectorAttr>()) if (LangOpts.getStackProtector() == LangOptions::SSPOff ||
(D && D->hasAttr<NoStackProtectorAttr>()))
B.addAttribute(llvm::Attribute::NoStackProtect); B.addAttribute(llvm::Attribute::NoStackProtect);
else if (LangOpts.getStackProtector() == LangOptions::SSPOn) else if (LangOpts.getStackProtector() == LangOptions::SSPOn)
B.addAttribute(llvm::Attribute::StackProtect); B.addAttribute(llvm::Attribute::StackProtect);
else if (LangOpts.getStackProtector() == LangOptions::SSPStrong) else if (LangOpts.getStackProtector() == LangOptions::SSPStrong)
B.addAttribute(llvm::Attribute::StackProtectStrong); B.addAttribute(llvm::Attribute::StackProtectStrong);
else if (LangOpts.getStackProtector() == LangOptions::SSPReq) else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
B.addAttribute(llvm::Attribute::StackProtectReq); B.addAttribute(llvm::Attribute::StackProtectReq);
▲ Show 20 Lines • Show All 4,593 Lines • Show Last 20 Lines

clang/lib/Driver/ToolChains/Clang.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,004 Lines • ▼ Show 20 Lines if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
options::OPT_fstack_protector)) { options::OPT_fstack_protector)) {
if (A->getOption().matches(options::OPT_fstack_protector)) if (A->getOption().matches(options::OPT_fstack_protector))
StackProtectorLevel = StackProtectorLevel =
std::max<>(LangOptions::SSPOn, DefaultStackProtectorLevel); std::max<>(LangOptions::SSPOn, DefaultStackProtectorLevel);
else if (A->getOption().matches(options::OPT_fstack_protector_strong)) else if (A->getOption().matches(options::OPT_fstack_protector_strong))
StackProtectorLevel = LangOptions::SSPStrong; StackProtectorLevel = LangOptions::SSPStrong;
else if (A->getOption().matches(options::OPT_fstack_protector_all)) else if (A->getOption().matches(options::OPT_fstack_protector_all))
StackProtectorLevel = LangOptions::SSPReq; StackProtectorLevel = LangOptions::SSPReq;
else if (A->getOption().matches(options::OPT_fno_stack_protector))
StackProtectorLevel = LangOptions::SSPOff;
} else { } else {
StackProtectorLevel = DefaultStackProtectorLevel; StackProtectorLevel = DefaultStackProtectorLevel;
} }
if (StackProtectorLevel) { if (StackProtectorLevel) {
CmdArgs.push_back("-stack-protector"); CmdArgs.push_back("-stack-protector");
CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel))); CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
} }
▲ Show 20 Lines • Show All 3,720 Lines • ▼ Show 20 Linesvoid Clang::AddClangCLArgs(const ArgList &Args, types::ID InputType,
// This controls whether or not we emit RTTI data for polymorphic types. // This controls whether or not we emit RTTI data for polymorphic types.
if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR, if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
/*Default=*/false)) /*Default=*/false))
CmdArgs.push_back("-fno-rtti-data"); CmdArgs.push_back("-fno-rtti-data");
// This controls whether or not we emit stack-protector instrumentation. // This controls whether or not we emit stack-protector instrumentation.
// In MSVC, Buffer Security Check (/GS) is on by default. // In MSVC, Buffer Security Check (/GS) is on by default.
LangOptions::StackProtectorMode SPM = LangOptions::SSPOff;
if (!isNVPTX && Args.hasFlag(options::OPT__SLASH_GS, options::OPT__SLASH_GS_, if (!isNVPTX && Args.hasFlag(options::OPT__SLASH_GS, options::OPT__SLASH_GS_,
/*Default=*/true)) { /*Default=*/true)) {
CmdArgs.push_back("-stack-protector"); SPM = LangOptions::SSPStrong;
CmdArgs.push_back(Args.MakeArgString(Twine(LangOptions::SSPStrong)));
} }
CmdArgs.push_back("-stack-protector");
CmdArgs.push_back(Args.MakeArgString(Twine(SPM)));
// Emit CodeView if -Z7, -Zd, or -gline-tables-only are present. // Emit CodeView if -Z7, -Zd, or -gline-tables-only are present.
if (Arg *DebugInfoArg = if (Arg *DebugInfoArg =
Args.getLastArg(options::OPT__SLASH_Z7, options::OPT__SLASH_Zd, Args.getLastArg(options::OPT__SLASH_Z7, options::OPT__SLASH_Zd,
options::OPT_gline_tables_only)) { options::OPT_gline_tables_only)) {
*EmitCodeView = true; *EmitCodeView = true;
if (DebugInfoArg->getOption().matches(options::OPT__SLASH_Z7)) if (DebugInfoArg->getOption().matches(options::OPT__SLASH_Z7))
*DebugInfoKind = codegenoptions::LimitedDebugInfo; *DebugInfoKind = codegenoptions::LimitedDebugInfo;
▲ Show 20 Lines • Show All 613 Lines • Show Last 20 Lines

clang/test/CXX/special/class.dtor/p3-0x.cpp

Show First 20 Lines • Show All 170 Lines • ▼ Show 20 Lines
// CHECK: define linkonce_odr {{.*}} @_ZN2SwIiED1Ev({{.*}} [[ATTRGRP:#[0-9]+]] // CHECK: define linkonce_odr {{.*}} @_ZN2SwIiED1Ev({{.*}} [[ATTRGRP:#[0-9]+]]
template <typename T> template <typename T>
struct TVC : VX struct TVC : VX
{ virtual ~TVC(); }; { virtual ~TVC(); };
template <typename T> template <typename T>
TVC<T>::~TVC() {} TVC<T>::~TVC() {}
// CHECK: attributes [[ATTRGRP]] = { noinline nounwind{{.*}} } // CHECK: attributes [[ATTRGRP]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGen/2008-04-08-NoExceptions.c

// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -o - %s | FileCheck %s
void f(void); void f(void);
void g(void) { void g(void) {
// CHECK: define void @g() [[NUW:#[0-9]+]] // CHECK: define void @g() [[NUW:#[0-9]+]]
// CHECK-NOT: call void @f() nounwind // CHECK-NOT: call void @f() nounwind
f(); f();
} }
// CHECK-NOT: declare void @f() [[NUW]] // CHECK-NOT: declare void @f() [[NUW]]
// CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGen/address-safety-attr-flavors.cpp

Show All 19 Lines
// RUN: -disable-O0-optnone -emit-llvm -o - %s | \ // RUN: -disable-O0-optnone -emit-llvm -o - %s | \
// RUN: FileCheck -check-prefix=CHECK-HWASAN %s // RUN: FileCheck -check-prefix=CHECK-HWASAN %s
// RUN: %clang_cc1 -triple i386-unknown-linux -fsanitize=kernel-hwaddress \ // RUN: %clang_cc1 -triple i386-unknown-linux -fsanitize=kernel-hwaddress \
// RUN: -disable-O0-optnone -emit-llvm -o - %s | \ // RUN: -disable-O0-optnone -emit-llvm -o - %s | \
// RUN: FileCheck -check-prefix=CHECK-KHWASAN %s // RUN: FileCheck -check-prefix=CHECK-KHWASAN %s
int HasSanitizeAddress() { return 1; } int HasSanitizeAddress() { return 1; }
// CHECK-NOASAN: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-NOASAN: {{Function Attrs: noinline nossp nounwind mustprogress$}}
// CHECK-ASAN: Function Attrs: noinline nounwind sanitize_address mustprogress // CHECK-ASAN: Function Attrs: noinline nossp nounwind sanitize_address mustprogress
// CHECK-KASAN: Function Attrs: noinline nounwind sanitize_address mustprogress // CHECK-KASAN: Function Attrs: noinline nossp nounwind sanitize_address mustprogress
// CHECK-HWASAN: Function Attrs: noinline nounwind sanitize_hwaddress mustprogress // CHECK-HWASAN: Function Attrs: noinline nossp nounwind sanitize_hwaddress mustprogress
// CHECK-KHWASAN: Function Attrs: noinline nounwind sanitize_hwaddress mustprogress // CHECK-KHWASAN: Function Attrs: noinline nossp nounwind sanitize_hwaddress mustprogress
__attribute__((no_sanitize("address"))) int NoSanitizeQuoteAddress() { __attribute__((no_sanitize("address"))) int NoSanitizeQuoteAddress() {
return 0; return 0;
} }
// CHECK-NOASAN: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-NOASAN: {{Function Attrs: noinline nossp nounwind mustprogress$}}
// CHECK-ASAN: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-ASAN: {{Function Attrs: noinline nossp nounwind mustprogress$}}
// CHECK-KASAN: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-KASAN: {{Function Attrs: noinline nossp nounwind mustprogress$}}
// CHECK-HWASAN: {{Function Attrs: noinline nounwind sanitize_hwaddress mustprogress$}} // CHECK-HWASAN: {{Function Attrs: noinline nossp nounwind sanitize_hwaddress mustprogress$}}
// CHECK-KHWASAN: {{Function Attrs: noinline nounwind sanitize_hwaddress mustprogress$}} // CHECK-KHWASAN: {{Function Attrs: noinline nossp nounwind sanitize_hwaddress mustprogress$}}
__attribute__((no_sanitize_address)) int NoSanitizeAddress() { return 0; } __attribute__((no_sanitize_address)) int NoSanitizeAddress() { return 0; }
// CHECK-NOASAN: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-NOASAN: {{Function Attrs: noinline nossp nounwind mustprogress$}}
// CHECK-ASAN: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-ASAN: {{Function Attrs: noinline nossp nounwind mustprogress$}}
// CHECK-KASAN: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-KASAN: {{Function Attrs: noinline nossp nounwind mustprogress$}}
// CHECK-HWASAN: {{Function Attrs: noinline nounwind sanitize_hwaddress mustprogress$}} // CHECK-HWASAN: {{Function Attrs: noinline nossp nounwind sanitize_hwaddress mustprogress$}}
// CHECK-KHWASAN: {{Function Attrs: noinline nounwind sanitize_hwaddress mustprogress$}} // CHECK-KHWASAN: {{Function Attrs: noinline nossp nounwind sanitize_hwaddress mustprogress$}}
__attribute__((no_sanitize("kernel-address"))) int NoSanitizeKernelAddress() { __attribute__((no_sanitize("kernel-address"))) int NoSanitizeKernelAddress() {
return 0; return 0;
} }
// CHECK-NOASAN: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-NOASAN: {{Function Attrs: noinline nossp nounwind mustprogress$}}
// CHECK-ASAN: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-ASAN: {{Function Attrs: noinline nossp nounwind mustprogress$}}
// CHECK-KASAN: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-KASAN: {{Function Attrs: noinline nossp nounwind mustprogress$}}
// CHECK-HWASAN: {{Function Attrs: noinline nounwind sanitize_hwaddress mustprogress$}} // CHECK-HWASAN: {{Function Attrs: noinline nossp nounwind sanitize_hwaddress mustprogress$}}
// CHECK-KHWASAN: {{Function Attrs: noinline nounwind sanitize_hwaddress mustprogress$}} // CHECK-KHWASAN: {{Function Attrs: noinline nossp nounwind sanitize_hwaddress mustprogress$}}
__attribute__((no_sanitize("hwaddress"))) int NoSanitizeHWAddress() { __attribute__((no_sanitize("hwaddress"))) int NoSanitizeHWAddress() {
return 0; return 0;
} }
// CHECK-NOASAN: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-NOASAN: {{Function Attrs: noinline nossp nounwind mustprogress$}}
// CHECK-ASAN: {{Function Attrs: noinline nounwind sanitize_address mustprogress$}} // CHECK-ASAN: {{Function Attrs: noinline nossp nounwind sanitize_address mustprogress$}}
// CHECK-KASAN: {{Function Attrs: noinline nounwind sanitize_address mustprogress$}} // CHECK-KASAN: {{Function Attrs: noinline nossp nounwind sanitize_address mustprogress$}}
// CHECK-HWASAN: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-HWASAN: {{Function Attrs: noinline nossp nounwind mustprogress$}}
// CHECK-KHWASAN: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-KHWASAN: {{Function Attrs: noinline nossp nounwind mustprogress$}}
__attribute__((no_sanitize("kernel-hwaddress"))) int NoSanitizeKernelHWAddress() { __attribute__((no_sanitize("kernel-hwaddress"))) int NoSanitizeKernelHWAddress() {
return 0; return 0;
} }
// CHECK-NOASAN: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-NOASAN: {{Function Attrs: noinline nossp nounwind mustprogress$}}
// CHECK-ASAN: {{Function Attrs: noinline nounwind sanitize_address mustprogress$}} // CHECK-ASAN: {{Function Attrs: noinline nossp nounwind sanitize_address mustprogress$}}
// CHECK-KASAN: {{Function Attrs: noinline nounwind sanitize_address mustprogress$}} // CHECK-KASAN: {{Function Attrs: noinline nossp nounwind sanitize_address mustprogress$}}
// CHECK-HWASAN: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-HWASAN: {{Function Attrs: noinline nossp nounwind mustprogress$}}
// CHECK-KHWASAN: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-KHWASAN: {{Function Attrs: noinline nossp nounwind mustprogress$}}

clang/test/CodeGen/address-safety-attr.cpp

Show First 20 Lines • Show All 136 Lines • ▼ Show 20 Lines
// Check that __cxx_global_var_init* get the sanitize_address attribute. // Check that __cxx_global_var_init* get the sanitize_address attribute.
int global1 = 0; int global1 = 0;
int global2 = *(int*)((char*)&global1+1); int global2 = *(int*)((char*)&global1+1);
// WITHOUT: @__cxx_global_var_init{{.*}}[[NOATTR:#[0-9]+]] // WITHOUT: @__cxx_global_var_init{{.*}}[[NOATTR:#[0-9]+]]
// BLFILE: @__cxx_global_var_init{{.*}}[[NOATTR:#[0-9]+]] // BLFILE: @__cxx_global_var_init{{.*}}[[NOATTR:#[0-9]+]]
// BLFUNC: @__cxx_global_var_init{{.*}}[[WITH:#[0-9]+]] // BLFUNC: @__cxx_global_var_init{{.*}}[[WITH:#[0-9]+]]
// ASAN: @__cxx_global_var_init{{.*}}[[WITH:#[0-9]+]] // ASAN: @__cxx_global_var_init{{.*}}[[WITH:#[0-9]+]]
// WITHOUT: attributes [[NOATTR]] = { noinline nounwind{{.*}} } // WITHOUT: attributes [[NOATTR]] = { noinline nossp nounwind{{.*}} }
// BLFILE: attributes [[WITH]] = { noinline nounwind sanitize_address{{.*}} } // BLFILE: attributes [[WITH]] = { noinline nossp nounwind sanitize_address{{.*}} }
// BLFILE: attributes [[NOATTR]] = { noinline nounwind{{.*}} } // BLFILE: attributes [[NOATTR]] = { noinline nossp nounwind{{.*}} }
// BLFUNC: attributes [[WITH]] = { noinline nounwind sanitize_address{{.*}} } // BLFUNC: attributes [[WITH]] = { noinline nossp nounwind sanitize_address{{.*}} }
// BLFUNC: attributes [[NOATTR]] = { noinline nounwind{{.*}} } // BLFUNC: attributes [[NOATTR]] = { noinline nossp nounwind{{.*}} }
// ASAN: attributes [[WITH]] = { noinline nounwind sanitize_address{{.*}} } // ASAN: attributes [[WITH]] = { noinline nossp nounwind sanitize_address{{.*}} }
// ASAN: attributes [[NOATTR]] = { noinline nounwind{{.*}} } // ASAN: attributes [[NOATTR]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGen/address-space-field1.c

Show All 31 Lines
} S; } S;
void test_addrspace(__addr1 S* p1, __addr2 S*p2) { void test_addrspace(__addr1 S* p1, __addr2 S*p2) {
// swap // swap
p1->a = p2->b; p1->a = p2->b;
p1->b = p2->a; p1->b = p2->a;
} }
// CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGen/alias.c

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
// CHECKCC: define arm_aapcs_vfpcc i32 @outer(i32 %a) [[NUW]] { // CHECKCC: define arm_aapcs_vfpcc i32 @outer(i32 %a) [[NUW]] {
// CHECKCC: call arm_aapcs_vfpcc i32 @inner(i32 %{{.*}}) // CHECKCC: call arm_aapcs_vfpcc i32 @inner(i32 %{{.*}})
int outer_weak(int a) { return inner_weak_a(a); } int outer_weak(int a) { return inner_weak_a(a); }
// CHECKCC: define arm_aapcs_vfpcc i32 @outer_weak(i32 %a) [[NUW]] { // CHECKCC: define arm_aapcs_vfpcc i32 @outer_weak(i32 %a) [[NUW]] {
// CHECKCC: call arm_aapcs_vfpcc i32 @inner_weak(i32 %{{.*}}) // CHECKCC: call arm_aapcs_vfpcc i32 @inner_weak(i32 %{{.*}})
// CHECKCC: define internal arm_aapcs_vfpcc i32 @inner_weak(i32 %a) [[NUW]] { // CHECKCC: define internal arm_aapcs_vfpcc i32 @inner_weak(i32 %a) [[NUW]] {
// CHECKBASIC: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECKBASIC: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }
// CHECKCC: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECKCC: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }
void test8_bar() {} void test8_bar() {}
void test8_foo() __attribute__((weak, alias("test8_bar"))); void test8_foo() __attribute__((weak, alias("test8_bar")));
void test8_zed() __attribute__((alias("test8_foo"))); void test8_zed() __attribute__((alias("test8_foo")));
void test9_bar(void) { } void test9_bar(void) { }
void test9_zed(void) __attribute__((section("test"))); void test9_zed(void) __attribute__((section("test")));
void test9_zed(void) __attribute__((alias("test9_bar"))); void test9_zed(void) __attribute__((alias("test9_bar")));
Show All 21 Lines

clang/test/CodeGen/arm-cmse-attr.c

Show All 32 Lines
// CHECK: call void %fptr() #2 // CHECK: call void %fptr() #2
// CHECK: define void @f2(void ()* nocapture %fptr) {{[^#]*}}#0 { // CHECK: define void @f2(void ()* nocapture %fptr) {{[^#]*}}#0 {
// CHECK: call void %fptr() #2 // CHECK: call void %fptr() #2
// CHECK: define void @f3() {{[^#]*}}#1 { // CHECK: define void @f3() {{[^#]*}}#1 {
// CHECK: define void @f4() {{[^#]*}}#1 { // CHECK: define void @f4() {{[^#]*}}#1 {
// CHECK-NOSE-NOT: cmse_nonsecure_entry // CHECK-NOSE-NOT: cmse_nonsecure_entry
// CHECK-NOSE-NOT: cmse_nonsecure_call // CHECK-NOSE-NOT: cmse_nonsecure_call
// CHECK-SE: attributes #0 = { nounwind // CHECK-SE: attributes #0 = { nossp nounwind
// CHECK-SE: attributes #1 = { {{.*}} "cmse_nonsecure_entry" // CHECK-SE: attributes #1 = { {{.*}} "cmse_nonsecure_entry"
// CHECK-SE: attributes #2 = { {{.*}} "cmse_nonsecure_call" // CHECK-SE: attributes #2 = { {{.*}} "cmse_nonsecure_call"

clang/test/CodeGen/attr-mustprogress-0.c

// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-attributes // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-attributes
// RUN: %clang_cc1 -std=c89 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -std=c89 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -std=c99 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -std=c99 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s
int a = 0; int a = 0;
int b = 0; int b = 0;
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @f1( // CHECK-LABEL: @f1(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[FOR_COND:%.*]] // CHECK-NEXT: br label [[FOR_COND:%.*]]
// CHECK: for.cond: // CHECK: for.cond:
// CHECK-NEXT: br i1 true, label [[FOR_BODY:%.*]], label [[FOR_END:%.*]] // CHECK-NEXT: br i1 true, label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
// CHECK: for.body: // CHECK: for.body:
// CHECK-NEXT: br label [[FOR_COND]] // CHECK-NEXT: br label [[FOR_COND]]
// CHECK: for.end: // CHECK: for.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void f1() { void f1() {
for (; 1;) { for (; 1;) {
} }
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @f2( // CHECK-LABEL: @f2(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[FOR_COND:%.*]] // CHECK-NEXT: br label [[FOR_COND:%.*]]
// CHECK: for.cond: // CHECK: for.cond:
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4 // CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4
// CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]] // CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
// CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]] // CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
// CHECK: for.body: // CHECK: for.body:
// CHECK-NEXT: br label [[FOR_COND]] // CHECK-NEXT: br label [[FOR_COND]]
// CHECK: for.end: // CHECK: for.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void f2() { void f2() {
for (; a == b;) { for (; a == b;) {
} }
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @F( // CHECK-LABEL: @F(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[FOR_COND:%.*]] // CHECK-NEXT: br label [[FOR_COND:%.*]]
// CHECK: for.cond: // CHECK: for.cond:
// CHECK-NEXT: br i1 true, label [[FOR_BODY:%.*]], label [[FOR_END:%.*]] // CHECK-NEXT: br i1 true, label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
// CHECK: for.body: // CHECK: for.body:
// CHECK-NEXT: br label [[FOR_COND]] // CHECK-NEXT: br label [[FOR_COND]]
// CHECK: for.end: // CHECK: for.end:
Show All 10 Lines
// //
void F() { void F() {
for (; 1;) { for (; 1;) {
} }
for (; a == b;) { for (; a == b;) {
} }
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @w1( // CHECK-LABEL: @w1(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[WHILE_BODY:%.*]] // CHECK-NEXT: br label [[WHILE_BODY:%.*]]
// CHECK: while.body: // CHECK: while.body:
// CHECK-NEXT: br label [[WHILE_BODY]] // CHECK-NEXT: br label [[WHILE_BODY]]
// //
void w1() { void w1() {
while (1) { while (1) {
} }
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @w2( // CHECK-LABEL: @w2(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[WHILE_COND:%.*]] // CHECK-NEXT: br label [[WHILE_COND:%.*]]
// CHECK: while.cond: // CHECK: while.cond:
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4 // CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4
// CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]] // CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
// CHECK-NEXT: br i1 [[CMP]], label [[WHILE_BODY:%.*]], label [[WHILE_END:%.*]] // CHECK-NEXT: br i1 [[CMP]], label [[WHILE_BODY:%.*]], label [[WHILE_END:%.*]]
// CHECK: while.body: // CHECK: while.body:
// CHECK-NEXT: br label [[WHILE_COND]] // CHECK-NEXT: br label [[WHILE_COND]]
// CHECK: while.end: // CHECK: while.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void w2() { void w2() {
while (a == b) { while (a == b) {
} }
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @W( // CHECK-LABEL: @W(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[WHILE_COND:%.*]] // CHECK-NEXT: br label [[WHILE_COND:%.*]]
// CHECK: while.cond: // CHECK: while.cond:
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4 // CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4
// CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]] // CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
// CHECK-NEXT: br i1 [[CMP]], label [[WHILE_BODY:%.*]], label [[WHILE_END:%.*]] // CHECK-NEXT: br i1 [[CMP]], label [[WHILE_BODY:%.*]], label [[WHILE_END:%.*]]
// CHECK: while.body: // CHECK: while.body:
// CHECK-NEXT: br label [[WHILE_COND]] // CHECK-NEXT: br label [[WHILE_COND]]
// CHECK: while.end: // CHECK: while.end:
// CHECK-NEXT: br label [[WHILE_BODY2:%.*]] // CHECK-NEXT: br label [[WHILE_BODY2:%.*]]
// CHECK: while.body2: // CHECK: while.body2:
// CHECK-NEXT: br label [[WHILE_BODY2]] // CHECK-NEXT: br label [[WHILE_BODY2]]
// //
void W() { void W() {
while (a == b) { while (a == b) {
} }
while (1) { while (1) {
} }
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @d1( // CHECK-LABEL: @d1(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[DO_BODY:%.*]] // CHECK-NEXT: br label [[DO_BODY:%.*]]
// CHECK: do.body: // CHECK: do.body:
// CHECK-NEXT: br label [[DO_COND:%.*]] // CHECK-NEXT: br label [[DO_COND:%.*]]
// CHECK: do.cond: // CHECK: do.cond:
// CHECK-NEXT: br i1 true, label [[DO_BODY]], label [[DO_END:%.*]] // CHECK-NEXT: br i1 true, label [[DO_BODY]], label [[DO_END:%.*]]
// CHECK: do.end: // CHECK: do.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void d1() { void d1() {
do { do {
} while (1); } while (1);
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @d2( // CHECK-LABEL: @d2(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[DO_BODY:%.*]] // CHECK-NEXT: br label [[DO_BODY:%.*]]
// CHECK: do.body: // CHECK: do.body:
// CHECK-NEXT: br label [[DO_COND:%.*]] // CHECK-NEXT: br label [[DO_COND:%.*]]
// CHECK: do.cond: // CHECK: do.cond:
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4 // CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4
// CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]] // CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
// CHECK-NEXT: br i1 [[CMP]], label [[DO_BODY]], label [[DO_END:%.*]] // CHECK-NEXT: br i1 [[CMP]], label [[DO_BODY]], label [[DO_END:%.*]]
// CHECK: do.end: // CHECK: do.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void d2() { void d2() {
do { do {
} while (a == b); } while (a == b);
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @D( // CHECK-LABEL: @D(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[DO_BODY:%.*]] // CHECK-NEXT: br label [[DO_BODY:%.*]]
// CHECK: do.body: // CHECK: do.body:
// CHECK-NEXT: br label [[DO_COND:%.*]] // CHECK-NEXT: br label [[DO_COND:%.*]]
// CHECK: do.cond: // CHECK: do.cond:
// CHECK-NEXT: br i1 true, label [[DO_BODY]], label [[DO_END:%.*]] // CHECK-NEXT: br i1 true, label [[DO_BODY]], label [[DO_END:%.*]]
// CHECK: do.end: // CHECK: do.end:
Show All 17 Lines

clang/test/CodeGen/attr-mustprogress-0.cpp

// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-attributes // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-attributes
// RUN: %clang_cc1 -std=c++98 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -std=c++98 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s
int a = 0; int a = 0;
int b = 0; int b = 0;
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @_Z2f1v( // CHECK-LABEL: @_Z2f1v(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[FOR_COND:%.*]] // CHECK-NEXT: br label [[FOR_COND:%.*]]
// CHECK: for.cond: // CHECK: for.cond:
// CHECK-NEXT: br i1 true, label [[FOR_BODY:%.*]], label [[FOR_END:%.*]] // CHECK-NEXT: br i1 true, label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
// CHECK: for.body: // CHECK: for.body:
// CHECK-NEXT: br label [[FOR_COND]] // CHECK-NEXT: br label [[FOR_COND]]
// CHECK: for.end: // CHECK: for.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void f1() { void f1() {
for (; 1;) { for (; 1;) {
} }
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @_Z2f2v( // CHECK-LABEL: @_Z2f2v(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[FOR_COND:%.*]] // CHECK-NEXT: br label [[FOR_COND:%.*]]
// CHECK: for.cond: // CHECK: for.cond:
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4 // CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4
// CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]] // CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
// CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]] // CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
// CHECK: for.body: // CHECK: for.body:
// CHECK-NEXT: br label [[FOR_COND]] // CHECK-NEXT: br label [[FOR_COND]]
// CHECK: for.end: // CHECK: for.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void f2() { void f2() {
for (; a == b;) { for (; a == b;) {
} }
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @_Z1Fv( // CHECK-LABEL: @_Z1Fv(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[FOR_COND:%.*]] // CHECK-NEXT: br label [[FOR_COND:%.*]]
// CHECK: for.cond: // CHECK: for.cond:
// CHECK-NEXT: br i1 true, label [[FOR_BODY:%.*]], label [[FOR_END:%.*]] // CHECK-NEXT: br i1 true, label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
// CHECK: for.body: // CHECK: for.body:
// CHECK-NEXT: br label [[FOR_COND]] // CHECK-NEXT: br label [[FOR_COND]]
// CHECK: for.end: // CHECK: for.end:
Show All 10 Lines
// //
void F() { void F() {
for (; 1;) { for (; 1;) {
} }
for (; a == b;) { for (; a == b;) {
} }
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @_Z2w1v( // CHECK-LABEL: @_Z2w1v(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[WHILE_BODY:%.*]] // CHECK-NEXT: br label [[WHILE_BODY:%.*]]
// CHECK: while.body: // CHECK: while.body:
// CHECK-NEXT: br label [[WHILE_BODY]] // CHECK-NEXT: br label [[WHILE_BODY]]
// //
void w1() { void w1() {
while (1) { while (1) {
} }
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @_Z2w2v( // CHECK-LABEL: @_Z2w2v(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[WHILE_COND:%.*]] // CHECK-NEXT: br label [[WHILE_COND:%.*]]
// CHECK: while.cond: // CHECK: while.cond:
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4 // CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4
// CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]] // CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
// CHECK-NEXT: br i1 [[CMP]], label [[WHILE_BODY:%.*]], label [[WHILE_END:%.*]] // CHECK-NEXT: br i1 [[CMP]], label [[WHILE_BODY:%.*]], label [[WHILE_END:%.*]]
// CHECK: while.body: // CHECK: while.body:
// CHECK-NEXT: br label [[WHILE_COND]] // CHECK-NEXT: br label [[WHILE_COND]]
// CHECK: while.end: // CHECK: while.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void w2() { void w2() {
while (a == b) { while (a == b) {
} }
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @_Z1Wv( // CHECK-LABEL: @_Z1Wv(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[WHILE_COND:%.*]] // CHECK-NEXT: br label [[WHILE_COND:%.*]]
// CHECK: while.cond: // CHECK: while.cond:
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4 // CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4
// CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]] // CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
// CHECK-NEXT: br i1 [[CMP]], label [[WHILE_BODY:%.*]], label [[WHILE_END:%.*]] // CHECK-NEXT: br i1 [[CMP]], label [[WHILE_BODY:%.*]], label [[WHILE_END:%.*]]
// CHECK: while.body: // CHECK: while.body:
// CHECK-NEXT: br label [[WHILE_COND]] // CHECK-NEXT: br label [[WHILE_COND]]
// CHECK: while.end: // CHECK: while.end:
// CHECK-NEXT: br label [[WHILE_BODY2:%.*]] // CHECK-NEXT: br label [[WHILE_BODY2:%.*]]
// CHECK: while.body2: // CHECK: while.body2:
// CHECK-NEXT: br label [[WHILE_BODY2]] // CHECK-NEXT: br label [[WHILE_BODY2]]
// //
void W() { void W() {
while (a == b) { while (a == b) {
} }
while (1) { while (1) {
} }
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @_Z2d1v( // CHECK-LABEL: @_Z2d1v(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[DO_BODY:%.*]] // CHECK-NEXT: br label [[DO_BODY:%.*]]
// CHECK: do.body: // CHECK: do.body:
// CHECK-NEXT: br label [[DO_COND:%.*]] // CHECK-NEXT: br label [[DO_COND:%.*]]
// CHECK: do.cond: // CHECK: do.cond:
// CHECK-NEXT: br i1 true, label [[DO_BODY]], label [[DO_END:%.*]] // CHECK-NEXT: br i1 true, label [[DO_BODY]], label [[DO_END:%.*]]
// CHECK: do.end: // CHECK: do.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void d1() { void d1() {
do { do {
} while (1); } while (1);
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @_Z2d2v( // CHECK-LABEL: @_Z2d2v(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[DO_BODY:%.*]] // CHECK-NEXT: br label [[DO_BODY:%.*]]
// CHECK: do.body: // CHECK: do.body:
// CHECK-NEXT: br label [[DO_COND:%.*]] // CHECK-NEXT: br label [[DO_COND:%.*]]
// CHECK: do.cond: // CHECK: do.cond:
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4 // CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4
// CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]] // CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
// CHECK-NEXT: br i1 [[CMP]], label [[DO_BODY]], label [[DO_END:%.*]] // CHECK-NEXT: br i1 [[CMP]], label [[DO_BODY]], label [[DO_END:%.*]]
// CHECK: do.end: // CHECK: do.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void d2() { void d2() {
do { do {
} while (a == b); } while (a == b);
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @_Z1Dv( // CHECK-LABEL: @_Z1Dv(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[DO_BODY:%.*]] // CHECK-NEXT: br label [[DO_BODY:%.*]]
// CHECK: do.body: // CHECK: do.body:
// CHECK-NEXT: br label [[DO_COND:%.*]] // CHECK-NEXT: br label [[DO_COND:%.*]]
// CHECK: do.cond: // CHECK: do.cond:
// CHECK-NEXT: br i1 true, label [[DO_BODY]], label [[DO_END:%.*]] // CHECK-NEXT: br i1 true, label [[DO_BODY]], label [[DO_END:%.*]]
// CHECK: do.end: // CHECK: do.end:
Show All 17 Lines

clang/test/CodeGen/attr-mustprogress-1.c

// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-attributes // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-attributes
// RUN: %clang_cc1 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -std=c11 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -std=c11 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -std=c18 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -std=c18 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -std=c2x -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -std=c2x -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s
int a = 0; int a = 0;
int b = 0; int b = 0;
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @f1( // CHECK-LABEL: @f1(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[FOR_COND:%.*]] // CHECK-NEXT: br label [[FOR_COND:%.*]]
// CHECK: for.cond: // CHECK: for.cond:
// CHECK-NEXT: br i1 true, label [[FOR_BODY:%.*]], label [[FOR_END:%.*]] // CHECK-NEXT: br i1 true, label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
// CHECK: for.body: // CHECK: for.body:
// CHECK-NEXT: br label [[FOR_COND]] // CHECK-NEXT: br label [[FOR_COND]]
// CHECK: for.end: // CHECK: for.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void f1() { void f1() {
for (; 1;) { for (; 1;) {
} }
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @f2( // CHECK-LABEL: @f2(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[FOR_COND:%.*]] // CHECK-NEXT: br label [[FOR_COND:%.*]]
// CHECK: for.cond: // CHECK: for.cond:
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4 // CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4
// CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]] // CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
// CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]] // CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
// CHECK: for.body: // CHECK: for.body:
// CHECK-NEXT: br label [[FOR_COND]], [[LOOP2:!llvm.loop !.*]] // CHECK-NEXT: br label [[FOR_COND]], [[LOOP2:!llvm.loop !.*]]
// CHECK: for.end: // CHECK: for.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void f2() { void f2() {
for (; a == b;) { for (; a == b;) {
} }
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @F( // CHECK-LABEL: @F(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[FOR_COND:%.*]] // CHECK-NEXT: br label [[FOR_COND:%.*]]
// CHECK: for.cond: // CHECK: for.cond:
// CHECK-NEXT: br i1 true, label [[FOR_BODY:%.*]], label [[FOR_END:%.*]] // CHECK-NEXT: br i1 true, label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
// CHECK: for.body: // CHECK: for.body:
// CHECK-NEXT: br label [[FOR_COND]] // CHECK-NEXT: br label [[FOR_COND]]
// CHECK: for.end: // CHECK: for.end:
Show All 10 Lines
// //
void F() { void F() {
for (; 1;) { for (; 1;) {
} }
for (; a == b;) { for (; a == b;) {
} }
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @w1( // CHECK-LABEL: @w1(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[WHILE_BODY:%.*]] // CHECK-NEXT: br label [[WHILE_BODY:%.*]]
// CHECK: while.body: // CHECK: while.body:
// CHECK-NEXT: br label [[WHILE_BODY]] // CHECK-NEXT: br label [[WHILE_BODY]]
// //
void w1() { void w1() {
while (1) { while (1) {
} }
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @w2( // CHECK-LABEL: @w2(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[WHILE_COND:%.*]] // CHECK-NEXT: br label [[WHILE_COND:%.*]]
// CHECK: while.cond: // CHECK: while.cond:
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4 // CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4
// CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]] // CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
// CHECK-NEXT: br i1 [[CMP]], label [[WHILE_BODY:%.*]], label [[WHILE_END:%.*]] // CHECK-NEXT: br i1 [[CMP]], label [[WHILE_BODY:%.*]], label [[WHILE_END:%.*]]
// CHECK: while.body: // CHECK: while.body:
// CHECK-NEXT: br label [[WHILE_COND]], [[LOOP5:!llvm.loop !.*]] // CHECK-NEXT: br label [[WHILE_COND]], [[LOOP5:!llvm.loop !.*]]
// CHECK: while.end: // CHECK: while.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void w2() { void w2() {
while (a == b) { while (a == b) {
} }
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @W( // CHECK-LABEL: @W(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[WHILE_COND:%.*]] // CHECK-NEXT: br label [[WHILE_COND:%.*]]
// CHECK: while.cond: // CHECK: while.cond:
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4 // CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4
// CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]] // CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
// CHECK-NEXT: br i1 [[CMP]], label [[WHILE_BODY:%.*]], label [[WHILE_END:%.*]] // CHECK-NEXT: br i1 [[CMP]], label [[WHILE_BODY:%.*]], label [[WHILE_END:%.*]]
// CHECK: while.body: // CHECK: while.body:
// CHECK-NEXT: br label [[WHILE_COND]], [[LOOP6:!llvm.loop !.*]] // CHECK-NEXT: br label [[WHILE_COND]], [[LOOP6:!llvm.loop !.*]]
// CHECK: while.end: // CHECK: while.end:
// CHECK-NEXT: br label [[WHILE_BODY2:%.*]] // CHECK-NEXT: br label [[WHILE_BODY2:%.*]]
// CHECK: while.body2: // CHECK: while.body2:
// CHECK-NEXT: br label [[WHILE_BODY2]] // CHECK-NEXT: br label [[WHILE_BODY2]]
// //
void W() { void W() {
while (a == b) { while (a == b) {
} }
while (1) { while (1) {
} }
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @d1( // CHECK-LABEL: @d1(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[DO_BODY:%.*]] // CHECK-NEXT: br label [[DO_BODY:%.*]]
// CHECK: do.body: // CHECK: do.body:
// CHECK-NEXT: br label [[DO_COND:%.*]] // CHECK-NEXT: br label [[DO_COND:%.*]]
// CHECK: do.cond: // CHECK: do.cond:
// CHECK-NEXT: br i1 true, label [[DO_BODY]], label [[DO_END:%.*]] // CHECK-NEXT: br i1 true, label [[DO_BODY]], label [[DO_END:%.*]]
// CHECK: do.end: // CHECK: do.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void d1() { void d1() {
do { do {
} while (1); } while (1);
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @d2( // CHECK-LABEL: @d2(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[DO_BODY:%.*]] // CHECK-NEXT: br label [[DO_BODY:%.*]]
// CHECK: do.body: // CHECK: do.body:
// CHECK-NEXT: br label [[DO_COND:%.*]] // CHECK-NEXT: br label [[DO_COND:%.*]]
// CHECK: do.cond: // CHECK: do.cond:
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4 // CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4
// CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]] // CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
// CHECK-NEXT: br i1 [[CMP]], label [[DO_BODY]], label [[DO_END:%.*]], [[LOOP7:!llvm.loop !.*]] // CHECK-NEXT: br i1 [[CMP]], label [[DO_BODY]], label [[DO_END:%.*]], [[LOOP7:!llvm.loop !.*]]
// CHECK: do.end: // CHECK: do.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void d2() { void d2() {
do { do {
} while (a == b); } while (a == b);
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @D( // CHECK-LABEL: @D(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[DO_BODY:%.*]] // CHECK-NEXT: br label [[DO_BODY:%.*]]
// CHECK: do.body: // CHECK: do.body:
// CHECK-NEXT: br label [[DO_COND:%.*]] // CHECK-NEXT: br label [[DO_COND:%.*]]
// CHECK: do.cond: // CHECK: do.cond:
// CHECK-NEXT: br i1 true, label [[DO_BODY]], label [[DO_END:%.*]] // CHECK-NEXT: br i1 true, label [[DO_BODY]], label [[DO_END:%.*]]
// CHECK: do.end: // CHECK: do.end:
Show All 17 Lines

clang/test/CodeGen/attr-mustprogress-1.cpp

// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-attributes // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-attributes
// RUN: %clang_cc1 -std=c++11 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -std=c++11 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -std=c++14 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -std=c++14 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -std=c++17 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -std=c++17 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -std=c++20 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -std=c++20 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s
int a = 0; int a = 0;
int b = 0; int b = 0;
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @_Z2f1v( // CHECK-LABEL: @_Z2f1v(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[FOR_COND:%.*]] // CHECK-NEXT: br label [[FOR_COND:%.*]]
// CHECK: for.cond: // CHECK: for.cond:
// CHECK-NEXT: br i1 true, label [[FOR_BODY:%.*]], label [[FOR_END:%.*]] // CHECK-NEXT: br i1 true, label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
// CHECK: for.body: // CHECK: for.body:
// CHECK-NEXT: br label [[FOR_COND]] // CHECK-NEXT: br label [[FOR_COND]]
// CHECK: for.end: // CHECK: for.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void f1() { void f1() {
for (; 1;) for (; 1;)
; ;
} }
// CHECK: Function Attrs: noinline nounwind optnone mustprogress // CHECK: Function Attrs: noinline nossp nounwind optnone mustprogress
// CHECK-LABEL: @_Z2f2v( // CHECK-LABEL: @_Z2f2v(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[FOR_COND:%.*]] // CHECK-NEXT: br label [[FOR_COND:%.*]]
// CHECK: for.cond: // CHECK: for.cond:
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4 // CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4
// CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]] // CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
// CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]] // CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
// CHECK: for.body: // CHECK: for.body:
// CHECK-NEXT: br label [[FOR_COND]], [[LOOP2:!llvm.loop !.*]] // CHECK-NEXT: br label [[FOR_COND]], [[LOOP2:!llvm.loop !.*]]
// CHECK: for.end: // CHECK: for.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void f2() { void f2() {
for (; a == b;) for (; a == b;)
; ;
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @_Z1Fv( // CHECK-LABEL: @_Z1Fv(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[FOR_COND:%.*]] // CHECK-NEXT: br label [[FOR_COND:%.*]]
// CHECK: for.cond: // CHECK: for.cond:
// CHECK-NEXT: br i1 true, label [[FOR_BODY:%.*]], label [[FOR_END:%.*]] // CHECK-NEXT: br i1 true, label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
// CHECK: for.body: // CHECK: for.body:
// CHECK-NEXT: br label [[FOR_COND]] // CHECK-NEXT: br label [[FOR_COND]]
// CHECK: for.end: // CHECK: for.end:
Show All 10 Lines
// //
void F() { void F() {
for (; 1;) for (; 1;)
; ;
for (; a == b;) for (; a == b;)
; ;
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @_Z2F2v( // CHECK-LABEL: @_Z2F2v(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[FOR_COND:%.*]] // CHECK-NEXT: br label [[FOR_COND:%.*]]
// CHECK: for.cond: // CHECK: for.cond:
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4 // CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4
// CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]] // CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
// CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]] // CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
Show All 10 Lines
// //
void F2() { void F2() {
for (; a == b;) for (; a == b;)
; ;
for (; 1;) for (; 1;)
; ;
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @_Z2w1v( // CHECK-LABEL: @_Z2w1v(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[WHILE_BODY:%.*]] // CHECK-NEXT: br label [[WHILE_BODY:%.*]]
// CHECK: while.body: // CHECK: while.body:
// CHECK-NEXT: br label [[WHILE_BODY]] // CHECK-NEXT: br label [[WHILE_BODY]]
// //
void w1() { void w1() {
while (1) while (1)
; ;
} }
// CHECK: Function Attrs: noinline nounwind optnone mustprogress // CHECK: Function Attrs: noinline nossp nounwind optnone mustprogress
// CHECK-LABEL: @_Z2w2v( // CHECK-LABEL: @_Z2w2v(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[WHILE_COND:%.*]] // CHECK-NEXT: br label [[WHILE_COND:%.*]]
// CHECK: while.cond: // CHECK: while.cond:
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4 // CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4
// CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]] // CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
// CHECK-NEXT: br i1 [[CMP]], label [[WHILE_BODY:%.*]], label [[WHILE_END:%.*]] // CHECK-NEXT: br i1 [[CMP]], label [[WHILE_BODY:%.*]], label [[WHILE_END:%.*]]
// CHECK: while.body: // CHECK: while.body:
// CHECK-NEXT: br label [[WHILE_COND]], [[LOOP6:!llvm.loop !.*]] // CHECK-NEXT: br label [[WHILE_COND]], [[LOOP6:!llvm.loop !.*]]
// CHECK: while.end: // CHECK: while.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void w2() { void w2() {
while (a == b) while (a == b)
; ;
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @_Z1Wv( // CHECK-LABEL: @_Z1Wv(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[WHILE_COND:%.*]] // CHECK-NEXT: br label [[WHILE_COND:%.*]]
// CHECK: while.cond: // CHECK: while.cond:
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4 // CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4
// CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]] // CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
// CHECK-NEXT: br i1 [[CMP]], label [[WHILE_BODY:%.*]], label [[WHILE_END:%.*]] // CHECK-NEXT: br i1 [[CMP]], label [[WHILE_BODY:%.*]], label [[WHILE_END:%.*]]
// CHECK: while.body: // CHECK: while.body:
// CHECK-NEXT: br label [[WHILE_COND]], [[LOOP7:!llvm.loop !.*]] // CHECK-NEXT: br label [[WHILE_COND]], [[LOOP7:!llvm.loop !.*]]
// CHECK: while.end: // CHECK: while.end:
// CHECK-NEXT: br label [[WHILE_BODY2:%.*]] // CHECK-NEXT: br label [[WHILE_BODY2:%.*]]
// CHECK: while.body2: // CHECK: while.body2:
// CHECK-NEXT: br label [[WHILE_BODY2]] // CHECK-NEXT: br label [[WHILE_BODY2]]
// //
void W() { void W() {
while (a == b) while (a == b)
; ;
while (1) while (1)
; ;
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @_Z2W2v( // CHECK-LABEL: @_Z2W2v(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[WHILE_BODY:%.*]] // CHECK-NEXT: br label [[WHILE_BODY:%.*]]
// CHECK: while.body: // CHECK: while.body:
// CHECK-NEXT: br label [[WHILE_BODY]] // CHECK-NEXT: br label [[WHILE_BODY]]
// //
void W2() { void W2() {
while (1) while (1)
; ;
while (a == b) while (a == b)
; ;
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @_Z2d1v( // CHECK-LABEL: @_Z2d1v(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[DO_BODY:%.*]] // CHECK-NEXT: br label [[DO_BODY:%.*]]
// CHECK: do.body: // CHECK: do.body:
// CHECK-NEXT: br label [[DO_COND:%.*]] // CHECK-NEXT: br label [[DO_COND:%.*]]
// CHECK: do.cond: // CHECK: do.cond:
// CHECK-NEXT: br i1 true, label [[DO_BODY]], label [[DO_END:%.*]] // CHECK-NEXT: br i1 true, label [[DO_BODY]], label [[DO_END:%.*]]
// CHECK: do.end: // CHECK: do.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void d1() { void d1() {
do do
; ;
while (1); while (1);
} }
// CHECK: Function Attrs: noinline nounwind optnone mustprogress // CHECK: Function Attrs: noinline nossp nounwind optnone mustprogress
// CHECK-LABEL: @_Z2d2v( // CHECK-LABEL: @_Z2d2v(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[DO_BODY:%.*]] // CHECK-NEXT: br label [[DO_BODY:%.*]]
// CHECK: do.body: // CHECK: do.body:
// CHECK-NEXT: br label [[DO_COND:%.*]] // CHECK-NEXT: br label [[DO_COND:%.*]]
// CHECK: do.cond: // CHECK: do.cond:
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4 // CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4
// CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]] // CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
// CHECK-NEXT: br i1 [[CMP]], label [[DO_BODY]], label [[DO_END:%.*]], [[LOOP8:!llvm.loop !.*]] // CHECK-NEXT: br i1 [[CMP]], label [[DO_BODY]], label [[DO_END:%.*]], [[LOOP8:!llvm.loop !.*]]
// CHECK: do.end: // CHECK: do.end:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// //
void d2() { void d2() {
do do
; ;
while (a == b); while (a == b);
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @_Z1Dv( // CHECK-LABEL: @_Z1Dv(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[DO_BODY:%.*]] // CHECK-NEXT: br label [[DO_BODY:%.*]]
// CHECK: do.body: // CHECK: do.body:
// CHECK-NEXT: br label [[DO_COND:%.*]] // CHECK-NEXT: br label [[DO_COND:%.*]]
// CHECK: do.cond: // CHECK: do.cond:
// CHECK-NEXT: br i1 true, label [[DO_BODY]], label [[DO_END:%.*]] // CHECK-NEXT: br i1 true, label [[DO_BODY]], label [[DO_END:%.*]]
// CHECK: do.end: // CHECK: do.end:
Show All 12 Linesvoid D() {
do do
; ;
while (1); while (1);
do do
; ;
while (a == b); while (a == b);
} }
// CHECK: Function Attrs: noinline nounwind optnone // CHECK: Function Attrs: noinline nossp nounwind optnone
// CHECK-LABEL: @_Z2D2v( // CHECK-LABEL: @_Z2D2v(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: br label [[DO_BODY:%.*]] // CHECK-NEXT: br label [[DO_BODY:%.*]]
// CHECK: do.body: // CHECK: do.body:
// CHECK-NEXT: br label [[DO_COND:%.*]] // CHECK-NEXT: br label [[DO_COND:%.*]]
// CHECK: do.cond: // CHECK: do.cond:
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4 // CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @b, align 4
Show All 20 Lines

clang/test/CodeGen/attr-naked.c

Show All 17 Lines
// Make sure not to generate prolog or epilog for naked functions. // Make sure not to generate prolog or epilog for naked functions.
__attribute((naked)) void t3(int x) { __attribute((naked)) void t3(int x) {
// CHECK: define void @t3(i32 %0) // CHECK: define void @t3(i32 %0)
// CHECK-NOT: alloca // CHECK-NOT: alloca
// CHECK-NOT: store // CHECK-NOT: store
// CHECK: unreachable // CHECK: unreachable
} }
// CHECK: attributes [[NAKED_OPTNONE]] = { naked noinline nounwind optnone{{.*}} } // CHECK: attributes [[NAKED_OPTNONE]] = { naked noinline nossp nounwind optnone{{.*}} }
// CHECK: attributes [[NAKED]] = { naked noinline nounwind{{.*}} } // CHECK: attributes [[NAKED]] = { naked noinline nossp nounwind{{.*}} }

clang/test/CodeGen/attributes.c

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Lines
// CHECK: call void %{{[a-z0-9]+}}() [[NOCF_CHECK_CALL:#[0-9]+]] // CHECK: call void %{{[a-z0-9]+}}() [[NOCF_CHECK_CALL:#[0-9]+]]
typedef void (*f_t)(void); typedef void (*f_t)(void);
void t24(f_t f1) { void t24(f_t f1) {
__attribute__((nocf_check)) f_t p = f1; __attribute__((nocf_check)) f_t p = f1;
(*p)(); (*p)();
} }
// CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }
// CHECK: attributes [[NR]] = { noinline noreturn nounwind{{.*}} } // CHECK: attributes [[NR]] = { noinline noreturn nossp nounwind{{.*}} }
// CHECK: attributes [[COLDDEF]] = { cold {{.*}}} // CHECK: attributes [[COLDDEF]] = { cold {{.*}}}
// CHECK: attributes [[COLDDECL]] = { cold {{.*}}} // CHECK: attributes [[COLDDECL]] = { cold {{.*}}}
// CHECK: attributes [[NOCF_CHECK_FUNC]] = { nocf_check {{.*}}} // CHECK: attributes [[NOCF_CHECK_FUNC]] = { nocf_check {{.*}}}
// CHECK: attributes [[COLDSITE]] = { cold {{.*}}} // CHECK: attributes [[COLDSITE]] = { cold {{.*}}}
// CHECK: attributes [[NOCF_CHECK_CALL]] = { nocf_check } // CHECK: attributes [[NOCF_CHECK_CALL]] = { nocf_check }

clang/test/CodeGen/exceptions-seh-finally.c

Show First 20 Lines • Show All 278 Lines • ▼ Show 20 Linesvoid finally_with_func() {
} }
} }
// CHECK-LABEL: define internal void @"?fin$0@0@finally_with_func@@"({{[^)]*}}) // CHECK-LABEL: define internal void @"?fin$0@0@finally_with_func@@"({{[^)]*}})
// CHECK: call void @cleanup_with_func(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @"??_C@_0BC@COAGBPGM@finally_with_func?$AA@", i{{32|64}} 0, i{{32|64}} 0)) // CHECK: call void @cleanup_with_func(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @"??_C@_0BC@COAGBPGM@finally_with_func?$AA@", i{{32|64}} 0, i{{32|64}} 0))
// Look for the absence of noinline. nounwind is expected; any further // Look for the absence of noinline. nounwind is expected; any further
// attributes should be string attributes. // attributes should be string attributes.
// CHECK: attributes [[finally_attrs]] = { nounwind "{{.*}}" } // CHECK: attributes [[finally_attrs]] = { nossp nounwind "{{.*}}" }

clang/test/CodeGen/function-attributes.c

Show First 20 Lines • Show All 103 Lines • ▼ Show 20 Lines
// CHECK: call i32 @_setjmp(i32* null) // CHECK: call i32 @_setjmp(i32* null)
// CHECK: [[RT_CALL]] // CHECK: [[RT_CALL]]
// CHECK: ret void // CHECK: ret void
int _setjmp(jmp_buf); int _setjmp(jmp_buf);
void f20(void) { void f20(void) {
_setjmp(0); _setjmp(0);
} }
// CHECK: attributes [[NUW]] = { nounwind optsize{{.*}} } // CHECK: attributes [[NUW]] = { nossp nounwind optsize{{.*}} }
// CHECK: attributes [[AI]] = { alwaysinline nounwind optsize{{.*}} } // CHECK: attributes [[AI]] = { alwaysinline nossp nounwind optsize{{.*}} }
// CHECK: attributes [[NUW_OS_RN]] = { nounwind optsize readnone{{.*}} } // CHECK: attributes [[NUW_OS_RN]] = { nossp nounwind optsize readnone{{.*}} }
// CHECK: attributes [[SR]] = { nounwind optsize{{.*}} "stackrealign"{{.*}} } // CHECK: attributes [[SR]] = { nossp nounwind optsize{{.*}} "stackrealign"{{.*}} }
// CHECK: attributes [[RT]] = { nounwind optsize returns_twice{{.*}} } // CHECK: attributes [[RT]] = { nossp nounwind optsize returns_twice{{.*}} }
// CHECK: attributes [[NR]] = { noreturn optsize } // CHECK: attributes [[NR]] = { noreturn optsize }
// CHECK: attributes [[NUW_RN]] = { nounwind optsize readnone } // CHECK: attributes [[NUW_RN]] = { nounwind optsize readnone }
// CHECK: attributes [[RT_CALL]] = { optsize returns_twice } // CHECK: attributes [[RT_CALL]] = { optsize returns_twice }

clang/test/CodeGen/incomplete-function-type-2.c

Show All 10 Linesvoid test10_bar() {
test10_foo(test10_b); test10_foo(test10_b);
} }
struct test10_B {}; struct test10_B {};
void test10_foo(test10_F3 p1) void test10_foo(test10_F3 p1)
{ {
p1(0.0); p1(0.0);
} }
// CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGen/memtag-attr.cpp

// Make sure the sanitize_memtag attribute is emitted when using MemTag sanitizer. // Make sure the sanitize_memtag attribute is emitted when using MemTag sanitizer.
// Make sure __attribute__((no_sanitize("memtag")) disables instrumentation. // Make sure __attribute__((no_sanitize("memtag")) disables instrumentation.
// RUN: %clang_cc1 -triple aarch64-unknown-linux -disable-O0-optnone \ // RUN: %clang_cc1 -triple aarch64-unknown-linux -disable-O0-optnone \
// RUN: -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-NO %s // RUN: -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-NO %s
// RUN: %clang_cc1 -triple aarch64-unknown-linux -fsanitize=memtag \ // RUN: %clang_cc1 -triple aarch64-unknown-linux -fsanitize=memtag \
// RUN: -disable-O0-optnone -emit-llvm -o - %s | \ // RUN: -disable-O0-optnone -emit-llvm -o - %s | \
// RUN: FileCheck -check-prefix=CHECK-MEMTAG %s // RUN: FileCheck -check-prefix=CHECK-MEMTAG %s
int HasSanitizeMemTag() { return 1; } int HasSanitizeMemTag() { return 1; }
// CHECK-NO: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-NO: {{Function Attrs: noinline nossp nounwind mustprogress$}}
// CHECK-MEMTAG: Function Attrs: noinline nounwind sanitize_memtag // CHECK-MEMTAG: Function Attrs: noinline nossp nounwind sanitize_memtag
__attribute__((no_sanitize("memtag"))) int NoSanitizeQuoteAddress() { __attribute__((no_sanitize("memtag"))) int NoSanitizeQuoteAddress() {
return 0; return 0;
} }
// CHECK-NO: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-NO: {{Function Attrs: noinline nossp nounwind mustprogress$}}
// CHECK-MEMTAG: {{Function Attrs: noinline nounwind mustprogress$}} // CHECK-MEMTAG: {{Function Attrs: noinline nossp nounwind mustprogress$}}

clang/test/CodeGen/micromips-attr.c

// RUN: %clang_cc1 -triple mips-linux-gnu -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -triple mips-linux-gnu -emit-llvm -o - %s | FileCheck %s
void __attribute__((micromips)) foo (void) {} void __attribute__((micromips)) foo (void) {}
// CHECK: define void @foo() [[MICROMIPS:#[0-9]+]] // CHECK: define void @foo() [[MICROMIPS:#[0-9]+]]
void __attribute__((nomicromips)) nofoo (void) {} void __attribute__((nomicromips)) nofoo (void) {}
// CHECK: define void @nofoo() [[NOMICROMIPS:#[0-9]+]] // CHECK: define void @nofoo() [[NOMICROMIPS:#[0-9]+]]
// CHECK: attributes [[MICROMIPS]] = { noinline nounwind {{.*}} "micromips" {{.*}} } // CHECK: attributes [[MICROMIPS]] = { noinline nossp nounwind {{.*}} "micromips" {{.*}} }
// CHECK: attributes [[NOMICROMIPS]] = { noinline nounwind {{.*}} "nomicromips" {{.*}} } // CHECK: attributes [[NOMICROMIPS]] = { noinline nossp nounwind {{.*}} "nomicromips" {{.*}} }

clang/test/CodeGen/mips-vector-arg.c

Show All 20 Lines
// O32: declare i32 @test_v4i32_2(i32 inreg, i32 inreg, i32 inreg, i32 inreg, i32 signext, i32, i32 inreg, i32 inreg, i32 inreg, i32 inreg) // O32: declare i32 @test_v4i32_2(i32 inreg, i32 inreg, i32 inreg, i32 inreg, i32 signext, i32, i32 inreg, i32 inreg, i32 inreg, i32 inreg)
// N64: define void @test_v4i32(i64 inreg %a1.coerce0, i64 inreg %a1.coerce1, i32 signext %a2, i64 %0, i64 inreg %a3.coerce0, i64 inreg %a3.coerce1) local_unnamed_addr [[NUW]] // N64: define void @test_v4i32(i64 inreg %a1.coerce0, i64 inreg %a1.coerce1, i32 signext %a2, i64 %0, i64 inreg %a3.coerce0, i64 inreg %a3.coerce1) local_unnamed_addr [[NUW]]
// N64: declare signext i32 @test_v4i32_2(i64 inreg, i64 inreg, i32 signext, i64, i64 inreg, i64 inreg) // N64: declare signext i32 @test_v4i32_2(i64 inreg, i64 inreg, i32 signext, i64, i64 inreg, i64 inreg)
extern test_v4i32_2(v4i32, int, v4i32); extern test_v4i32_2(v4i32, int, v4i32);
void test_v4i32(v4i32 a1, int a2, v4i32 a3) { void test_v4i32(v4i32 a1, int a2, v4i32 a3) {
test_v4i32_2(a3, a2, a1); test_v4i32_2(a3, a2, a1);
} }
// O32: attributes [[NUW]] = { nounwind{{.*}} } // O32: attributes [[NUW]] = { nossp nounwind{{.*}} }
// N64: attributes [[NUW]] = { nounwind{{.*}} } // N64: attributes [[NUW]] = { nossp nounwind{{.*}} }

clang/test/CodeGen/mips16-attr.c

// RUN: %clang_cc1 -triple mipsel-linux-gnu -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -triple mipsel-linux-gnu -emit-llvm -o - %s | FileCheck %s
void __attribute__((mips16)) foo (void) { void __attribute__((mips16)) foo (void) {
} }
// CHECK: define void @foo() [[MIPS16:#[0-9]+]] // CHECK: define void @foo() [[MIPS16:#[0-9]+]]
void __attribute__((nomips16)) nofoo (void) { void __attribute__((nomips16)) nofoo (void) {
} }
// CHECK: define void @nofoo() [[NOMIPS16:#[0-9]+]] // CHECK: define void @nofoo() [[NOMIPS16:#[0-9]+]]
// CHECK: attributes [[MIPS16]] = { noinline nounwind {{.*}} "mips16" {{.*}} } // CHECK: attributes [[MIPS16]] = { noinline nossp nounwind {{.*}} "mips16" {{.*}} }
// CHECK: attributes [[NOMIPS16]] = { noinline nounwind {{.*}} "nomips16" {{.*}} } // CHECK: attributes [[NOMIPS16]] = { noinline nossp nounwind {{.*}} "nomips16" {{.*}} }

clang/test/CodeGen/mrtd.c

Show All 19 Lines
// CHECK: define void @qux(i32 %arg, ...) // CHECK: define void @qux(i32 %arg, ...)
void quux(int a1, int a2, int a3) { void quux(int a1, int a2, int a3) {
qux(a1, a2, a3); qux(a1, a2, a3);
} }
// CHECK-LABEL: define x86_stdcallcc void @quux // CHECK-LABEL: define x86_stdcallcc void @quux
// CHECK: call void (i32, ...) @qux // CHECK: call void (i32, ...) @qux
// CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGen/ms-declspecs.c

Show All 31 Lines
// CHECK: call void @f20_t() [[NR:#[0-9]+]] // CHECK: call void @f20_t() [[NR:#[0-9]+]]
__declspec(noreturn) void f20_t(void); __declspec(noreturn) void f20_t(void);
void f20(void) { f20_t(); } void f20(void) { f20_t(); }
__declspec(noalias) void noalias_callee(int *x); __declspec(noalias) void noalias_callee(int *x);
// CHECK: call void @noalias_callee({{.*}}) [[NA:#[0-9]+]] // CHECK: call void @noalias_callee({{.*}}) [[NA:#[0-9]+]]
void noalias_caller(int *x) { noalias_callee(x); } void noalias_caller(int *x) { noalias_callee(x); }
// CHECK: attributes [[NAKED]] = { naked noinline nounwind{{.*}} } // CHECK: attributes [[NAKED]] = { naked noinline nossp nounwind{{.*}} }
// CHECK: attributes [[NUW]] = { nounwind{{.*}} } // CHECK: attributes [[NUW]] = { nossp nounwind{{.*}} }
// CHECK: attributes [[NI]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NI]] = { noinline nossp nounwind{{.*}} }
// CHECK: attributes [[NR]] = { noreturn } // CHECK: attributes [[NR]] = { noreturn }
// CHECK: attributes [[NA]] = { argmemonly nounwind{{.*}} } // CHECK: attributes [[NA]] = { argmemonly nounwind{{.*}} }

clang/test/CodeGen/ppc64-complex-parms.c

Show First 20 Lines • Show All 185 Lines • ▼ Show 20 Lines
// CHECK: store i64 2, i64* %[[VAR72]] // CHECK: store i64 2, i64* %[[VAR72]]
// CHECK: store i64 -3, i64* %[[VAR73]] // CHECK: store i64 -3, i64* %[[VAR73]]
// CHECK: %[[VAR74:[A-Za-z0-9.]+]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[VAR71]], i32 0, i32 0 // CHECK: %[[VAR74:[A-Za-z0-9.]+]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[VAR71]], i32 0, i32 0
// CHECK: %[[VAR75:[A-Za-z0-9.]+]] = load i64, i64* %[[VAR74]], align 8 // CHECK: %[[VAR75:[A-Za-z0-9.]+]] = load i64, i64* %[[VAR74]], align 8
// CHECK: %[[VAR76:[A-Za-z0-9.]+]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[VAR71]], i32 0, i32 1 // CHECK: %[[VAR76:[A-Za-z0-9.]+]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[VAR71]], i32 0, i32 1
// CHECK: %[[VAR77:[A-Za-z0-9.]+]] = load i64, i64* %[[VAR76]], align 8 // CHECK: %[[VAR77:[A-Za-z0-9.]+]] = load i64, i64* %[[VAR76]], align 8
// CHECK: %{{[A-Za-z0-9.]+}} = call i64 @foo_long_long(i64 %[[VAR75]], i64 %[[VAR77]]) // CHECK: %{{[A-Za-z0-9.]+}} = call i64 @foo_long_long(i64 %[[VAR75]], i64 %[[VAR77]])
// CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGen/ppc64-complex-return.c

Show First 20 Lines • Show All 142 Lines • ▼ Show 20 Lines
} }
// CHECK: define i64 @bar_long_long() [[NUW]] { // CHECK: define i64 @bar_long_long() [[NUW]] {
// CHECK: [[VAR8:[%A-Za-z0-9.]+]] = call { i64, i64 } @foo_long_long // CHECK: [[VAR8:[%A-Za-z0-9.]+]] = call { i64, i64 } @foo_long_long
// CHECK: extractvalue { i64, i64 } [[VAR8]], 0 // CHECK: extractvalue { i64, i64 } [[VAR8]], 0
// CHECK: extractvalue { i64, i64 } [[VAR8]], 1 // CHECK: extractvalue { i64, i64 } [[VAR8]], 1
// CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGen/ppc64-extend.c

// REQUIRES: powerpc-registered-target // REQUIRES: powerpc-registered-target
// RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
void f1(int x) { return; } void f1(int x) { return; }
// CHECK: define void @f1(i32 signext %x) [[NUW:#[0-9]+]] // CHECK: define void @f1(i32 signext %x) [[NUW:#[0-9]+]]
void f2(unsigned int x) { return; } void f2(unsigned int x) { return; }
// CHECK: define void @f2(i32 zeroext %x) [[NUW]] // CHECK: define void @f2(i32 zeroext %x) [[NUW]]
int f3(void) { return 0; } int f3(void) { return 0; }
// CHECK: define signext i32 @f3() [[NUW]] // CHECK: define signext i32 @f3() [[NUW]]
unsigned int f4(void) { return 0; } unsigned int f4(void) { return 0; }
// CHECK: define zeroext i32 @f4() [[NUW]] // CHECK: define zeroext i32 @f4() [[NUW]]
// CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGen/pragma-weak.c

Show First 20 Lines • Show All 182 Lines • ▼ Show 20 Lines
void yyy(void){} void yyy(void){}
void zzz(void){} void zzz(void){}
#pragma weak yyy #pragma weak yyy
// NOTE: weak doesn't apply, not before or in same TopLevelDec(!) // NOTE: weak doesn't apply, not before or in same TopLevelDec(!)
// CHECK-LABEL: define void @yyy() // CHECK-LABEL: define void @yyy()
int correct_linkage; int correct_linkage;
// CHECK: attributes [[NI]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NI]] = { noinline nossp nounwind{{.*}} }
// CHECK: attributes [[RN]] = { noinline nounwind optnone readnone{{.*}} } // CHECK: attributes [[RN]] = { noinline nossp nounwind optnone readnone{{.*}} }

clang/test/CodeGen/sanitize-thread-attr.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
// Check that __cxx_global_var_init* get the sanitize_thread attribute. // Check that __cxx_global_var_init* get the sanitize_thread attribute.
int global1 = 0; int global1 = 0;
int global2 = *(int*)((char*)&global1+1); int global2 = *(int*)((char*)&global1+1);
// WITHOUT: @__cxx_global_var_init{{.*}}[[NOATTR:#[0-9]+]] // WITHOUT: @__cxx_global_var_init{{.*}}[[NOATTR:#[0-9]+]]
// BL: @__cxx_global_var_init{{.*}}[[NOATTR:#[0-9]+]] // BL: @__cxx_global_var_init{{.*}}[[NOATTR:#[0-9]+]]
// TSAN: @__cxx_global_var_init{{.*}}[[WITH:#[0-9]+]] // TSAN: @__cxx_global_var_init{{.*}}[[WITH:#[0-9]+]]
// WITHOUT: attributes [[NOATTR]] = { noinline nounwind{{.*}} } // WITHOUT: attributes [[NOATTR]] = { noinline nossp nounwind{{.*}} }
// BL: attributes [[NOATTR]] = { noinline nounwind{{.*}} } // BL: attributes [[NOATTR]] = { noinline nossp nounwind{{.*}} }
// TSAN: attributes [[NOATTR]] = { noinline nounwind{{.*}} } // TSAN: attributes [[NOATTR]] = { noinline nossp nounwind{{.*}} }
// TSAN: attributes [[WITH]] = { noinline nounwind sanitize_thread{{.*}} } // TSAN: attributes [[WITH]] = { noinline nossp nounwind sanitize_thread{{.*}} }

clang/test/CodeGen/sanitize-thread-no-checking-at-run-time.m

Show All 32 Lines
// TSAN: cxx_destruct{{.*}}) [[ATTR:#[0-9]+]] // TSAN: cxx_destruct{{.*}}) [[ATTR:#[0-9]+]]
void test2(id x) { void test2(id x) {
extern void test2_helper(id (^)(void)); extern void test2_helper(id (^)(void));
test2_helper(^{ return x; }); test2_helper(^{ return x; });
// TSAN: define linkonce_odr hidden void @__destroy_helper_block_8_32o(i8* %0) unnamed_addr [[ATTR:#[0-9]+]] // TSAN: define linkonce_odr hidden void @__destroy_helper_block_8_32o(i8* %0) unnamed_addr [[ATTR:#[0-9]+]]
} }
// TSAN: attributes [[ATTR]] = { noinline nounwind {{.*}} "sanitize_thread_no_checking_at_run_time" {{.*}} } // TSAN: attributes [[ATTR]] = { noinline nossp nounwind {{.*}} "sanitize_thread_no_checking_at_run_time" {{.*}} }

clang/test/CodeGen/stackrealign-main.c

// RUN: %clang_cc1 -triple i386-unknown-unknown -emit-llvm -o - -mstack-alignment=64 %s | FileCheck %s // RUN: %clang_cc1 -triple i386-unknown-unknown -emit-llvm -o - -mstack-alignment=64 %s | FileCheck %s
// CHECK-LABEL: define void @other() // CHECK-LABEL: define void @other()
// CHECK: [[OTHER:#[0-9]+]] // CHECK: [[OTHER:#[0-9]+]]
// CHECK: { // CHECK: {
void other(void) {} void other(void) {}
// CHECK-LABEL: define i32 @main( // CHECK-LABEL: define i32 @main(
// CHECK: [[MAIN:#[0-9]+]] // CHECK: [[MAIN:#[0-9]+]]
// CHECK: { // CHECK: {
int main(int argc, char **argv) { int main(int argc, char **argv) {
other(); other();
return 0; return 0;
} }
// CHECK: attributes [[OTHER]] = { noinline nounwind optnone // CHECK: attributes [[OTHER]] = { noinline nossp nounwind optnone
// CHECK-NOT: "stackrealign" // CHECK-NOT: "stackrealign"
// CHECK: } // CHECK: }
// CHECK: attributes [[MAIN]] = { noinline nounwind optnone {{.*}}"stackrealign"{{.*}} } // CHECK: attributes [[MAIN]] = { noinline nossp nounwind optnone {{.*}}"stackrealign"{{.*}} }

clang/test/CodeGen/unwind-attr.c

Show All 17 Lines
// <rdar://problem/8283071>: not for weak functions // <rdar://problem/8283071>: not for weak functions
// CHECK: define weak [[INT:i.*]] @test2() [[TF]] { // CHECK: define weak [[INT:i.*]] @test2() [[TF]] {
// CHECK-NOEXC: define weak [[INT:i.*]] @test2() [[NUW]] { // CHECK-NOEXC: define weak [[INT:i.*]] @test2() [[NUW]] {
__attribute__((weak)) int test2(void) { __attribute__((weak)) int test2(void) {
return 0; return 0;
} }
// CHECK: attributes [[TF]] = { noinline optnone "{{.*}} } // CHECK: attributes [[TF]] = { noinline nossp optnone "{{.*}} }
// CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }
// CHECK-NOEXC: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK-NOEXC: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGen/xray-global-init.cpp

// RUN: %clang_cc1 -triple=x86_64-linux-gnu -emit-llvm -fxray-instrument -fxray-instruction-threshold=1 %s -o - \ // RUN: %clang_cc1 -triple=x86_64-linux-gnu -emit-llvm -fxray-instrument -fxray-instruction-threshold=1 %s -o - \
// RUN: | FileCheck %s // RUN: | FileCheck %s
struct A { struct A {
A(); A();
~A(); ~A();
}; };
A a; A a;
// Check that the xray-instruction-threshold was applied // Check that the xray-instruction-threshold was applied
// CHECK: define internal void @_GLOBAL__sub_I_xray_global_init.cpp() [[NUX:#[0-9]+]] section ".text.startup" { // CHECK: define internal void @_GLOBAL__sub_I_xray_global_init.cpp() [[NUX:#[0-9]+]] section ".text.startup" {
// CHECK: attributes [[NUX]] = { noinline nounwind {{.*}}"xray-instruction-threshold"="1"{{.*}} } // CHECK: attributes [[NUX]] = { noinline nossp nounwind {{.*}}"xray-instruction-threshold"="1"{{.*}} }

clang/test/CodeGenCXX/apple-kext.cpp

Show All 34 Lines
// CHECK: define internal void [[CTOR0]]() // CHECK: define internal void [[CTOR0]]()
// CHECK: call void [[CTOR0_]]() // CHECK: call void [[CTOR0_]]()
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// CHECK: define internal void [[DTOR0]]() // CHECK: define internal void [[DTOR0]]()
// CHECK: call void @_ZN5test01AD1Ev([[A]]* @_ZN5test01aE) // CHECK: call void @_ZN5test01AD1Ev([[A]]* @_ZN5test01aE)
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// CHECK: attributes #[[ATTR0]] = { alwaysinline nounwind {{.*}} } // CHECK: attributes #[[ATTR0]] = { alwaysinline nossp nounwind {{.*}} }
// CHECK: attributes #[[ATTR1]] = { noinline nounwind {{.*}} } // CHECK: attributes #[[ATTR1]] = { noinline nossp nounwind {{.*}} }

clang/test/CodeGenCXX/attr.cpp

Show All 25 Lines
void C::bar4() { } void C::bar4() { }
// PR6635 // PR6635
// CHECK-LABEL: define i32 @_Z5test1v() // CHECK-LABEL: define i32 @_Z5test1v()
int test1() { return 10; } int test1() { return 10; }
// CHECK at top of file // CHECK at top of file
extern "C" int test2() __attribute__((alias("_Z5test1v"))); extern "C" int test2() __attribute__((alias("_Z5test1v")));
// CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGenCXX/cxx11-exception-spec.cpp

Show First 20 Lines • Show All 115 Lines • ▼ Show 20 Linesvoid j() {
// CHECK: declare {{.*}} @_ZN6NestedIiE1fILb1EcEEvv( // CHECK: declare {{.*}} @_ZN6NestedIiE1fILb1EcEEvv(
// CHECK-NOT: [[NUW]] // CHECK-NOT: [[NUW]]
Nested<int>().f<true, char>(); Nested<int>().f<true, char>();
// CHECK: declare {{.*}} @_ZN6NestedIlE1fILb0ElEEvv({{.*}}) [[NUW2]] // CHECK: declare {{.*}} @_ZN6NestedIlE1fILb0ElEEvv({{.*}}) [[NUW2]]
Nested<long>().f<false, long>(); Nested<long>().f<false, long>();
} }
// CHECK: attributes [[NONE]] = { {{.*}} } // CHECK: attributes [[NONE]] = { {{.*}} }
// CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }
// CHECK: attributes [[NUW2]] = { nounwind{{.*}} } // CHECK: attributes [[NUW2]] = { nounwind{{.*}} }
namespace PR19190 { namespace PR19190 {
template <class T> struct DWFIterator { virtual void get() throw(int) = 0; }; template <class T> struct DWFIterator { virtual void get() throw(int) = 0; };
void foo(DWFIterator<int> *foo) { foo->get(); } void foo(DWFIterator<int> *foo) { foo->get(); }
} }

clang/test/CodeGenCXX/cxx11-noreturn.cpp

// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -std=c++11 %s -o - | FileCheck %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -std=c++11 %s -o - | FileCheck %s
int g(); int g();
// CHECK: _Z1fv(){{.*}} [[NR:#[0-9]+]] // CHECK: _Z1fv(){{.*}} [[NR:#[0-9]+]]
[[noreturn]] int f() { [[noreturn]] int f() {
while (g()) {} while (g()) {}
} }
// CHECK: attributes [[NR]] = { noinline noreturn nounwind{{.*}} } // CHECK: attributes [[NR]] = { noinline noreturn nossp nounwind{{.*}} }

clang/test/CodeGenCXX/derived-to-base.cpp

Show All 40 Linesnamespace test3 {
struct B : A {}; struct B : A {};
void foo(A a); void foo(A a);
void test() { void test() {
foo(B()); foo(B());
} }
} }
// CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGenCXX/exceptions-seh-filter-uwtable.cpp

Show All 29 Lines
g aq(h j, g k, int, int) { g aq(h j, g k, int, int) {
if (k) if (k)
return; return;
j.ad(); j.ad();
} }
// Check for the uwtable attribute on the filter funclet. // Check for the uwtable attribute on the filter funclet.
// CHECK: define internal i32 @"?filt$0@0@at@@"(i8* %exception_pointers, i8* %frame_pointer) #[[MD:[0-9]+]] // CHECK: define internal i32 @"?filt$0@0@at@@"(i8* %exception_pointers, i8* %frame_pointer) #[[MD:[0-9]+]]
// CHECK: attributes #[[MD]] = { nounwind uwtable // CHECK: attributes #[[MD]] = { nossp nounwind uwtable
void at() { void at() {
i ar; i ar;
__try { __try {
ar->ad(); ar->ad();
} __except (aq(*ar, _exception_code(), 0, 0)) { } __except (aq(*ar, _exception_code(), 0, 0)) {
} }
} }

clang/test/CodeGenCXX/global-dtor-no-atexit.cpp

Show All 37 Lines
// CHECK: define internal void @__dtor__ZZ4funcvE2a2() [[NUW]] // CHECK: define internal void @__dtor__ZZ4funcvE2a2() [[NUW]]
// CHECK: call void @_ZN1AD1Ev([[A]]* @_ZZ4funcvE2a2) // CHECK: call void @_ZN1AD1Ev([[A]]* @_ZZ4funcvE2a2)
void func() { void func() {
static A a1, a2; static A a1, a2;
} }
// CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGenCXX/global-init.cpp

Show First 20 Lines • Show All 198 Lines • ▼ Show 20 Lines
// CHECK-NEXT: store i32 {{.*}}, i32* @_ZN5test1L1yE // CHECK-NEXT: store i32 {{.*}}, i32* @_ZN5test1L1yE
// CHECK: define internal void @_GLOBAL__sub_I_global_init.cpp() #{{[0-9]+}} section "__TEXT,__StaticInit,regular,pure_instructions" { // CHECK: define internal void @_GLOBAL__sub_I_global_init.cpp() #{{[0-9]+}} section "__TEXT,__StaticInit,regular,pure_instructions" {
// CHECK: call void [[TEST1_Y_INIT]] // CHECK: call void [[TEST1_Y_INIT]]
// CHECK: call void [[TEST1_Z_INIT]] // CHECK: call void [[TEST1_Z_INIT]]
// rdar://problem/8090834: this should be nounwind // rdar://problem/8090834: this should be nounwind
// CHECK-NOEXC: define internal void @_GLOBAL__sub_I_global_init.cpp() [[NUW:#[0-9]+]] section "__TEXT,__StaticInit,regular,pure_instructions" { // CHECK-NOEXC: define internal void @_GLOBAL__sub_I_global_init.cpp() [[NUW:#[0-9]+]] section "__TEXT,__StaticInit,regular,pure_instructions" {
// CHECK-NOEXC: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK-NOEXC: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }
// Make sure we mark global initializers with the no-builtins attribute. // Make sure we mark global initializers with the no-builtins attribute.
// CHECK-NOBUILTIN: define internal void @_GLOBAL__sub_I_global_init.cpp() [[NUW:#[0-9]+]] section "__TEXT,__StaticInit,regular,pure_instructions" { // CHECK-NOBUILTIN: define internal void @_GLOBAL__sub_I_global_init.cpp() [[NUW:#[0-9]+]] section "__TEXT,__StaticInit,regular,pure_instructions" {
// CHECK-NOBUILTIN: attributes [[NUW]] = { noinline nounwind{{.*}}"no-builtins"{{.*}} } // CHECK-NOBUILTIN: attributes [[NUW]] = { noinline nossp nounwind{{.*}}"no-builtins"{{.*}} }
// PR21811: attach the appropriate attribute to the global init function // PR21811: attach the appropriate attribute to the global init function
// CHECK-FP: define internal void @_GLOBAL__sub_I_global_init.cpp() [[NUX:#[0-9]+]] section "__TEXT,__StaticInit,regular,pure_instructions" { // CHECK-FP: define internal void @_GLOBAL__sub_I_global_init.cpp() [[NUX:#[0-9]+]] section "__TEXT,__StaticInit,regular,pure_instructions" {
// CHECK-FP: attributes [[NUX]] = { noinline nounwind {{.*}}"frame-pointer"="non-leaf"{{.*}} } // CHECK-FP: attributes [[NUX]] = { noinline nossp nounwind {{.*}}"frame-pointer"="non-leaf"{{.*}} }

clang/test/CodeGenCXX/microsoft-abi-array-cookies.cpp

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Linesstruct S {
char x[42]; char x[42];
void operator delete[](void *p, __SIZE_TYPE__); void operator delete[](void *p, __SIZE_TYPE__);
// CHECK-LABEL: define dso_local void @"?delete_s@PR23990@@YAXPAUS@1@@Z"( // CHECK-LABEL: define dso_local void @"?delete_s@PR23990@@YAXPAUS@1@@Z"(
// CHECK: call void @"??_VS@PR23990@@SAXPAXI@Z"(i8* {{.*}}, i32 42) // CHECK: call void @"??_VS@PR23990@@SAXPAXI@Z"(i8* {{.*}}, i32 42)
}; };
void delete_s(S *s) { delete[] s; } void delete_s(S *s) { delete[] s; }
} }
// CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGenCXX/no-exceptions.cpp

// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s
void g(); void g();
// CHECK: define void @_Z1fv() [[NUW:#[0-9]+]] // CHECK: define void @_Z1fv() [[NUW:#[0-9]+]]
void f() throw (int) { void f() throw (int) {
// CHECK-NOT: invoke void @_Z1gv // CHECK-NOT: invoke void @_Z1gv
g(); g();
// CHECK: call void @_Z1gv() // CHECK: call void @_Z1gv()
// CHECK: ret void // CHECK: ret void
} }
// CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGenCXX/noinline-template.cpp

Show All 9 Lines
}; };
template <class T> __attribute__((noinline)) void Vector<T>::growStorageBy() { template <class T> __attribute__((noinline)) void Vector<T>::growStorageBy() {
} }
void foo() { void foo() {
Vector<int> strs; Vector<int> strs;
strs.growStorageBy(); strs.growStorageBy();
} }
// CHECK: attributes [[NI]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NI]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGenCXX/optnone-def-decl.cpp

Show First 20 Lines • Show All 83 Lines • ▼ Show 20 Lines
int user_of_forceinline_optnone_function() { int user_of_forceinline_optnone_function() {
return forceinline_optnone_function(4,5); return forceinline_optnone_function(4,5);
} }
// CHECK: @_Z36user_of_forceinline_optnone_functionv() [[NORMAL]] // CHECK: @_Z36user_of_forceinline_optnone_functionv() [[NORMAL]]
// CHECK: @_Z28forceinline_optnone_functionii({{.*}}) [[OPTNONE]] // CHECK: @_Z28forceinline_optnone_functionii({{.*}}) [[OPTNONE]]
// CHECK: attributes [[OPTNONE]] = { noinline nounwind optnone {{.*}} } // CHECK: attributes [[OPTNONE]] = { noinline nossp nounwind optnone {{.*}} }
// CHECK: attributes [[NORMAL]] = // CHECK: attributes [[NORMAL]] =
// CHECK-NOT: noinline // CHECK-NOT: noinline
// CHECK-NOT: optnone // CHECK-NOT: optnone

clang/test/CodeGenCXX/reference-cast.cpp

Show First 20 Lines • Show All 187 Lines • ▼ Show 20 Linesnamespace PR10650 {
}; };
unsigned long long test(Helper *obj) { unsigned long long test(Helper *obj) {
return static_cast<const unsigned long long&>(obj->id()); return static_cast<const unsigned long long&>(obj->id());
} }
// CHECK-LABEL: define i64 @_ZN7PR106504testEPNS_6HelperE // CHECK-LABEL: define i64 @_ZN7PR106504testEPNS_6HelperE
// CHECK: store i64 // CHECK: store i64
} }
// CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGenCXX/threadsafe-statics.cpp

Show All 16 Lines
// NO-TSS: @_ZZ1gvE1a = internal global i32 0, align 4 // NO-TSS: @_ZZ1gvE1a = internal global i32 0, align 4
// NO-TSS: @_ZGVZ1gvE1a = internal global i8 0 // NO-TSS: @_ZGVZ1gvE1a = internal global i8 0
// NO-TSS: define void @_Z1gv() [[NUW:#[0-9]+]] // NO-TSS: define void @_Z1gv() [[NUW:#[0-9]+]]
// NO-TSS-NOT: call i32 @__cxa_guard_acquire // NO-TSS-NOT: call i32 @__cxa_guard_acquire
// NO-TSS-NOT: call void @__cxa_guard_release // NO-TSS-NOT: call void @__cxa_guard_release
// NO-TSS: ret void // NO-TSS: ret void
// WITH-TSS: attributes [[NUW]] = { noinline nounwind{{.*}} } // WITH-TSS: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }
// NO-TSS: attributes [[NUW]] = { noinline nounwind{{.*}} } // NO-TSS: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGenCXX/thunks.cpp

Show First 20 Lines • Show All 536 Lines • ▼ Show 20 Lines
// This is from Test10: // This is from Test10:
// CHECK-OPT-LABEL: define linkonce_odr void @_ZN6Test101C3fooEv // CHECK-OPT-LABEL: define linkonce_odr void @_ZN6Test101C3fooEv
// CHECK-OPT-LABEL: define linkonce_odr void @_ZThn8_N6Test101C3fooEv // CHECK-OPT-LABEL: define linkonce_odr void @_ZThn8_N6Test101C3fooEv
// This is from Test10: // This is from Test10:
// WIN64-LABEL: define linkonce_odr dso_local void @"?foo@C@Test10@@UEAAXXZ"( // WIN64-LABEL: define linkonce_odr dso_local void @"?foo@C@Test10@@UEAAXXZ"(
// WIN64-LABEL: define linkonce_odr dso_local void @"?foo@C@Test10@@W7EAAXXZ"( // WIN64-LABEL: define linkonce_odr dso_local void @"?foo@C@Test10@@W7EAAXXZ"(
// CHECK-NONOPT: attributes [[NUW]] = { noinline nounwind optnone uwtable{{.*}} } // CHECK-NONOPT: attributes [[NUW]] = { noinline nossp nounwind optnone uwtable{{.*}} }
// CHECK-OPT: attributes [[NUW]] = { nounwind uwtable{{.*}} } // CHECK-OPT: attributes [[NUW]] = { nossp nounwind uwtable{{.*}} }

clang/test/CodeGenCXX/virtual-base-cast.cpp

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Lines
// MSVC: %[[vbptr_off:.*]] = getelementptr inbounds i8, i8* {{.*}}, i32 4 // MSVC: %[[vbptr_off:.*]] = getelementptr inbounds i8, i8* {{.*}}, i32 4
// MSVC: %[[vbptr:.*]] = bitcast i8* %[[vbptr_off]] to i32** // MSVC: %[[vbptr:.*]] = bitcast i8* %[[vbptr_off]] to i32**
// MSVC: %[[vbtable:.*]] = load i32*, i32** %[[vbptr]] // MSVC: %[[vbtable:.*]] = load i32*, i32** %[[vbptr]]
// MSVC: %[[entry:.*]] = getelementptr inbounds i32, i32* {{.*}}, i32 4 // MSVC: %[[entry:.*]] = getelementptr inbounds i32, i32* {{.*}}, i32 4
// MSVC: %[[offset:.*]] = load i32, i32* %[[entry]] // MSVC: %[[offset:.*]] = load i32, i32* %[[entry]]
// MSVC: add nsw i32 4, %[[offset]] // MSVC: add nsw i32 4, %[[offset]]
// MSVC: } // MSVC: }
// CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} } // CHECK: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGenObjC/gnu-exceptions.m

Show All 26 Lines @try {
// NEW-ABI: objc_end_catch // NEW-ABI: objc_end_catch
log(0); log(0);
} }
log(1); log(1);
} }
// CHECK: attributes [[TF]] = { noinline optnone "{{.*}} } // CHECK: attributes [[TF]] = { noinline nossp optnone "{{.*}} }

clang/test/CodeGenObjC/objc-literal-tests.m

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Lines
// rdar://10579122 // rdar://10579122
typedef BOOL (^foo)(void); typedef BOOL (^foo)(void);
extern void bar(foo a); extern void bar(foo a);
void baz(void) { void baz(void) {
bar(^(void) { return YES; }); bar(^(void) { return YES; });
} }
// CHECK: attributes [[NUW]] = { noinline {{(norecurse )?}}nounwind{{.*}} } // CHECK: attributes [[NUW]] = { noinline {{(norecurse )?}}nossp nounwind{{.*}} }

clang/test/CodeGenObjCXX/lambda-expressions.mm

Show First 20 Lines • Show All 158 Lines • ▼ Show 20 Lines
void test() { void test() {
void (*p)(Weak) = [](Weak a) { }; void (*p)(Weak) = [](Weak a) { };
} }
}; };
#endif #endif
// ARC: attributes [[NUW]] = { noinline nounwind{{.*}} } // ARC: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }
// MRC: attributes [[NUW]] = { noinline nounwind{{.*}} } // MRC: attributes [[NUW]] = { noinline nossp nounwind{{.*}} }

clang/test/CodeGenOpenCL/convergent.cl

Show First 20 Lines • Show All 133 Lines • ▼ Show 20 Lines
// CHECK-LABEL: @assume_convergent_asm // CHECK-LABEL: @assume_convergent_asm
// CHECK: tail call void asm sideeffect "s_barrier", ""() #5 // CHECK: tail call void asm sideeffect "s_barrier", ""() #5
kernel void assume_convergent_asm() kernel void assume_convergent_asm()
{ {
__asm__ volatile("s_barrier"); __asm__ volatile("s_barrier");
} }
// CHECK: attributes #0 = { nofree noinline norecurse nounwind " // CHECK: attributes #0 = { nofree noinline norecurse nossp nounwind "
// CHECK: attributes #1 = { {{[^}]*}}convergent{{[^}]*}} } // CHECK: attributes #1 = { {{[^}]*}}convergent{{[^}]*}} }
// CHECK: attributes #2 = { {{[^}]*}}convergent{{[^}]*}} } // CHECK: attributes #2 = { {{[^}]*}}convergent{{[^}]*}} }
// CHECK: attributes #3 = { {{[^}]*}}convergent noduplicate{{[^}]*}} } // CHECK: attributes #3 = { {{[^}]*}}convergent noduplicate{{[^}]*}} }
// CHECK: attributes #4 = { {{[^}]*}}convergent{{[^}]*}} } // CHECK: attributes #4 = { {{[^}]*}}convergent{{[^}]*}} }
// CHECK: attributes #5 = { {{[^}]*}}convergent{{[^}]*}} } // CHECK: attributes #5 = { {{[^}]*}}convergent{{[^}]*}} }
// CHECK: attributes #6 = { {{[^}]*}}convergent noduplicate{{[^}]*}} } // CHECK: attributes #6 = { {{[^}]*}}convergent noduplicate{{[^}]*}} }

clang/test/Driver/cl-options.c

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Lines
// Security Buffer Check is on by default. // Security Buffer Check is on by default.
// RUN: %clang_cl -### -- %s 2>&1 | FileCheck -check-prefix=GS-default %s // RUN: %clang_cl -### -- %s 2>&1 | FileCheck -check-prefix=GS-default %s
// GS-default: "-stack-protector" "2" // GS-default: "-stack-protector" "2"
// RUN: %clang_cl /GS -### -- %s 2>&1 | FileCheck -check-prefix=GS %s // RUN: %clang_cl /GS -### -- %s 2>&1 | FileCheck -check-prefix=GS %s
// GS: "-stack-protector" "2" // GS: "-stack-protector" "2"
// RUN: %clang_cl /GS- -### -- %s 2>&1 | FileCheck -check-prefix=GS_ %s // RUN: %clang_cl /GS- -### -- %s 2>&1 | FileCheck -check-prefix=GS_ %s
// GS_-NOT: -stack-protector // GS_: "-stack-protector" "0"
// RUN: %clang_cl /Gy -### -- %s 2>&1 | FileCheck -check-prefix=Gy %s // RUN: %clang_cl /Gy -### -- %s 2>&1 | FileCheck -check-prefix=Gy %s
// Gy: -ffunction-sections // Gy: -ffunction-sections
// RUN: %clang_cl /Gy /Gy- -### -- %s 2>&1 | FileCheck -check-prefix=Gy_ %s // RUN: %clang_cl /Gy /Gy- -### -- %s 2>&1 | FileCheck -check-prefix=Gy_ %s
// Gy_-NOT: -ffunction-sections // Gy_-NOT: -ffunction-sections
// RUN: %clang_cl /Gs -### -- %s 2>&1 | FileCheck -check-prefix=Gs %s // RUN: %clang_cl /Gs -### -- %s 2>&1 | FileCheck -check-prefix=Gs %s
▲ Show 20 Lines • Show All 593 Lines • Show Last 20 Lines

clang/test/PCH/objc_container.m

Show All 15 Lines
// CHECK-IR: define {{.*}}void @all() #0 // CHECK-IR: define {{.*}}void @all() #0
// CHECK-IR: {{call.*objc_msgSend}} // CHECK-IR: {{call.*objc_msgSend}}
// CHECK-IR: {{call.*objc_msgSend}} // CHECK-IR: {{call.*objc_msgSend}}
// CHECK-IR: {{call.*objc_msgSend}} // CHECK-IR: {{call.*objc_msgSend}}
// CHECK-IR: {{call.*objc_msgSend}} // CHECK-IR: {{call.*objc_msgSend}}
// CHECK-IR: ret void // CHECK-IR: ret void
// CHECK-IR: attributes #0 = { noinline nounwind {{.*}} } // CHECK-IR: attributes #0 = { noinline nossp nounwind {{.*}} }
// CHECK-IR: attributes #1 = { nonlazybind } // CHECK-IR: attributes #1 = { nonlazybind }

clang/test/utils/update_cc_test_checks/Inputs/check-attributes.cpp.funcattrs.expected

// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-attributes // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-attributes
// RUN: %clang_cc1 -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
struct RT { struct RT {
char A; char A;
int B[10][20]; int B[10][20];
char C; char C;
}; };
struct ST { struct ST {
int X; int X;
double Y; double Y;
struct RT Z; struct RT Z;
}; };
// CHECK: Function Attrs: noinline nounwind optnone mustprogress // CHECK: Function Attrs: noinline nossp nounwind optnone mustprogress
// CHECK-LABEL: @_Z3fooP2ST( // CHECK-LABEL: @_Z3fooP2ST(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: [[S_ADDR:%.*]] = alloca %struct.ST*, align 8 // CHECK-NEXT: [[S_ADDR:%.*]] = alloca %struct.ST*, align 8
// CHECK-NEXT: store %struct.ST* [[S:%.*]], %struct.ST** [[S_ADDR]], align 8 // CHECK-NEXT: store %struct.ST* [[S:%.*]], %struct.ST** [[S_ADDR]], align 8
// CHECK-NEXT: [[TMP0:%.*]] = load %struct.ST*, %struct.ST** [[S_ADDR]], align 8 // CHECK-NEXT: [[TMP0:%.*]] = load %struct.ST*, %struct.ST** [[S_ADDR]], align 8
// CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[TMP0]], i64 1 // CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[TMP0]], i64 1
// CHECK-NEXT: [[Z:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ARRAYIDX]], i32 0, i32 2 // CHECK-NEXT: [[Z:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ARRAYIDX]], i32 0, i32 2
// CHECK-NEXT: [[B:%.*]] = getelementptr inbounds [[STRUCT_RT:%.*]], %struct.RT* [[Z]], i32 0, i32 1 // CHECK-NEXT: [[B:%.*]] = getelementptr inbounds [[STRUCT_RT:%.*]], %struct.RT* [[Z]], i32 0, i32 1
// CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds [10 x [20 x i32]], [10 x [20 x i32]]* [[B]], i64 0, i64 5 // CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds [10 x [20 x i32]], [10 x [20 x i32]]* [[B]], i64 0, i64 5
// CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds [20 x i32], [20 x i32]* [[ARRAYIDX1]], i64 0, i64 13 // CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds [20 x i32], [20 x i32]* [[ARRAYIDX1]], i64 0, i64 13
// CHECK-NEXT: ret i32* [[ARRAYIDX2]] // CHECK-NEXT: ret i32* [[ARRAYIDX2]]
// //
int *foo(struct ST *s) { int *foo(struct ST *s) {
return &s[1].Z.B[5][13]; return &s[1].Z.B[5][13];
} }