This is an archive of the discontinued LLVM Phabricator instance.

Differential D2545

Remove the -cxx-abi command-line option
ClosedPublic

Authored by hans on Jan 13 2014, 5:07 PM.

Details

Reviewers
rnk
Commits
rL199250: Remove the -cxx-abi command-line flag.
Summary

This removes the -cxx-abi flag and makes the ABI depend just on the triple. It doesn't make sense to compile with "-triple i686-pc-win32 -cxx-abi itanium", so there's no need for this extra knob.

To be able to run a test with a specific ABI without constraining it to a specific triple, new substitutions are added to lit: %itanium_abi_triple and %ms_abi_triple can be used to get the current target triple adjusted to the desired ABI. For example, if the test suite is running with i686-pc-win32 target, %itanium_abi_triple will expand to i686-pc-mingw32.

Apologies for the large number of test updates. It's mostly mechanical, though :)

Diff Detail

Event Timeline

rnk accepted this revision.Jan 13 2014, 5:24 PM

LGTM with suggestions

We should probably announce on cfe-dev that -cxx-abi is gone and all you need now is the triple. Even though it was a -cc1 flag, lots of people are using it with the gcc compatible driver.

lib/Frontend/CompilerInvocation.cpp
1633

Let's kill off this TargetOptions field and use Triple instead. There should be very few instances of code looking at this. We should keep the TargetCXXABI enum stuff.

test/lit.cfg
251

These debug prints should go away.

hans updated this revision to Unknown Object (????).Jan 14 2014, 9:51 AM

Removing TargetOptions::CXXABI

hans closed this revision.Jan 14 2014, 11:43 AM

Closed by commit rL199250 (authored by @hans).

rnk mentioned this in D85802: [clang] Add -fc++-abi= flag for specifying which C++ ABI to use.Oct 14 2020, 4:07 PM

Revision Contents

PathSize
include/
clang/
Driver/
2 lines
lib/
Driver/
4 lines
Frontend/
6 lines
test/
CXX/
dcl.dcl/
dcl.link/
2 lines
dcl.spec/
dcl.constexpr/
2 lines
drs/
12 lines
special/
class.copy/
6 lines
class.dtor/
2 lines
4 lines
CodeGen/
2 lines
2 lines
2 lines
2 lines
3 lines
4 lines
10 lines
2 lines
CodeGenCUDA/
4 lines
CodeGenCXX/
4 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
4 lines
2 lines
4 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
4 lines
4 lines
2 lines
4 lines
4 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
10 lines
6 lines
8 lines
4 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
CodeGenObjC/
2 lines
2 lines
CodeGenObjCXX/
2 lines
2 lines
CodeGenOpenCL/
4 lines
2 lines
Driver/
1 line
Layout/
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
6 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
PCH/
6 lines
6 lines
22 lines
4 lines
8 lines
6 lines
Sema/
5 lines
4 lines
2 lines
SemaCXX/
2 lines
2 lines
4 lines
4 lines
4 lines
2 lines
4 lines
2 lines
2 lines
4 lines
4 lines
2 lines
4 lines
8 lines
4 lines
SemaObjCXX/
2 lines
SemaTemplate/
8 lines
2 lines
4 lines
2 lines
4 lines
24 lines

Diff 6439

include/clang/Driver/CC1Options.td

Show All 11 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
let Flags = [CC1Option, NoDriverOption] in { let Flags = [CC1Option, NoDriverOption] in {
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Target Options // Target Options
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def cxx_abi : Separate<["-"], "cxx-abi">,
HelpText<"Target a particular C++ ABI type">;
def target_abi : Separate<["-"], "target-abi">, def target_abi : Separate<["-"], "target-abi">,
HelpText<"Target a particular ABI type">; HelpText<"Target a particular ABI type">;
def target_cpu : Separate<["-"], "target-cpu">, def target_cpu : Separate<["-"], "target-cpu">,
HelpText<"Target a specific cpu type">; HelpText<"Target a specific cpu type">;
def mfpmath : Separate<["-"], "mfpmath">, def mfpmath : Separate<["-"], "mfpmath">,
HelpText<"Which unit to use for fp math">; HelpText<"Which unit to use for fp math">;
def target_feature : Separate<["-"], "target-feature">, def target_feature : Separate<["-"], "target-feature">,
HelpText<"Target specific attributes">; HelpText<"Target specific attributes">;
▲ Show 20 Lines • Show All 529 Lines • Show Last 20 Lines

lib/Driver/Tools.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,926 Lines • ▼ Show 20 Lines default:
llvm_unreachable("Unexpected option ID."); llvm_unreachable("Unexpected option ID.");
} }
// This provides POSIX compatibility (maps 'open' to '_open'), which most // This provides POSIX compatibility (maps 'open' to '_open'), which most
// users want. The /Za flag to cl.exe turns this off, but it's not // users want. The /Za flag to cl.exe turns this off, but it's not
// implemented in clang. // implemented in clang.
CmdArgs.push_back("--dependent-lib=oldnames"); CmdArgs.push_back("--dependent-lib=oldnames");
// FIXME: Make this default for the win32 triple.
CmdArgs.push_back("-cxx-abi");
CmdArgs.push_back("microsoft");
if (Arg *A = Args.getLastArg(options::OPT_show_includes)) if (Arg *A = Args.getLastArg(options::OPT_show_includes))
A->render(Args, CmdArgs); A->render(Args, CmdArgs);
if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) { if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
CmdArgs.push_back("-fdiagnostics-format"); CmdArgs.push_back("-fdiagnostics-format");
if (Args.hasArg(options::OPT__SLASH_fallback)) if (Args.hasArg(options::OPT__SLASH_fallback))
CmdArgs.push_back("msvc-fallback"); CmdArgs.push_back("msvc-fallback");
else else
▲ Show 20 Lines • Show All 3,269 Lines • Show Last 20 Lines

lib/Frontend/CompilerInvocation.cpp

Show First 20 Lines • Show All 1,612 Lines • ▼ Show 20 Linesstatic void ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts,
Opts.ShowMacroComments = Args.hasArg(OPT_CC); Opts.ShowMacroComments = Args.hasArg(OPT_CC);
Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD); Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
Opts.RewriteIncludes = Args.hasArg(OPT_frewrite_includes); Opts.RewriteIncludes = Args.hasArg(OPT_frewrite_includes);
} }
static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args) { static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args) {
using namespace options; using namespace options;
Opts.ABI = Args.getLastArgValue(OPT_target_abi); Opts.ABI = Args.getLastArgValue(OPT_target_abi);
Opts.CXXABI = Args.getLastArgValue(OPT_cxx_abi);
Opts.CPU = Args.getLastArgValue(OPT_target_cpu); Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
Opts.FPMath = Args.getLastArgValue(OPT_mfpmath); Opts.FPMath = Args.getLastArgValue(OPT_mfpmath);
Opts.FeaturesAsWritten = Args.getAllArgValues(OPT_target_feature); Opts.FeaturesAsWritten = Args.getAllArgValues(OPT_target_feature);
Opts.LinkerVersion = Args.getLastArgValue(OPT_target_linker_version); Opts.LinkerVersion = Args.getLastArgValue(OPT_target_linker_version);
Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple)); Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
// Use the default target triple if unspecified. // Use the default target triple if unspecified.
if (Opts.Triple.empty()) if (Opts.Triple.empty())
Opts.Triple = llvm::sys::getDefaultTargetTriple(); Opts.Triple = llvm::sys::getDefaultTargetTriple();
// Use the MS ABI for Win32 targets unless otherwise specified. // Use the MS ABI for Win32 targets.
if (Opts.CXXABI.empty() && if (llvm::Triple(Opts.Triple).getOS() == llvm::Triple::Win32)
llvm::Triple(Opts.Triple).getOS() == llvm::Triple::Win32)
Opts.CXXABI = "microsoft"; Opts.CXXABI = "microsoft";
rnkUnsubmitted
Not Done
ReplyInline Actions

Let's kill off this TargetOptions field and use Triple instead. There should be very few instances of code looking at this. We should keep the TargetCXXABI enum stuff.

rnk: Let's kill off this TargetOptions field and use Triple instead. There should be very few…
} }
bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res, bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
const char *const *ArgBegin, const char *const *ArgBegin,
const char *const *ArgEnd, const char *const *ArgEnd,
DiagnosticsEngine &Diags) { DiagnosticsEngine &Diags) {
bool Success = true; bool Success = true;
▲ Show 20 Lines • Show All 214 Lines • Show Last 20 Lines

test/CXX/dcl.dcl/dcl.link/p7.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
struct X { }; struct X { };
// CHECK: @x1 = global %struct.X zeroinitializer // CHECK: @x1 = global %struct.X zeroinitializer
// CHECK: @x4 = global %struct.X zeroinitializer // CHECK: @x4 = global %struct.X zeroinitializer
// CHECK: @x2 = external global %struct.X // CHECK: @x2 = external global %struct.X
// CHECK: @x3 = external global %struct.X // CHECK: @x3 = external global %struct.X
extern "C" { extern "C" {
Show All 19 Lines

test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p2.cpp

// RUN: %clang_cc1 -std=c++11 -emit-llvm -cxx-abi itanium %s -o - | FileCheck %s // RUN: %clang_cc1 -std=c++11 -emit-llvm -triple %itanium_abi_triple %s -o - | FileCheck %s
// constexpr functions and constexpr constructors are implicitly inline. // constexpr functions and constexpr constructors are implicitly inline.
struct S { struct S {
constexpr S(int n); constexpr S(int n);
constexpr int g(); constexpr int g();
int n; int n;
}; };
Show All 17 Lines

test/CXX/drs/dr2xx.cpp

// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -cxx-abi itanium // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -cxx-abi itanium // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
// RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -cxx-abi itanium // RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -cxx-abi microsoft -DMSABI // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %ms_abi_triple -DMSABI
// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -cxx-abi microsoft -DMSABI // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %ms_abi_triple -DMSABI
// RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -cxx-abi microsoft -DMSABI // RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %ms_abi_triple -DMSABI
// PR13819 -- __SIZE_TYPE__ is incompatible. // PR13819 -- __SIZE_TYPE__ is incompatible.
typedef __SIZE_TYPE__ size_t; // expected-error 0-1 {{extension}} typedef __SIZE_TYPE__ size_t; // expected-error 0-1 {{extension}}
#if __cplusplus < 201103L #if __cplusplus < 201103L
#define fold(x) (__builtin_constant_p(x) ? (x) : (x)) #define fold(x) (__builtin_constant_p(x) ? (x) : (x))
#else #else
#define fold #define fold
▲ Show 20 Lines • Show All 1,017 Lines • Show Last 20 Lines

test/CXX/special/class.copy/implicit-move-def.cpp

// FIXME: %clang_cc1 -emit-llvm -cxx-abi itanium -o - -std=c++11 %s | FileCheck -check-prefix=CHECK %s // FIXME: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -o - -std=c++11 %s | FileCheck -check-prefix=CHECK %s
// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -o - -std=c++11 %s | FileCheck -check-prefix=CHECK-ASSIGN %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -o - -std=c++11 %s | FileCheck -check-prefix=CHECK-ASSIGN %s
// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -o - -std=c++11 %s | FileCheck -check-prefix=CHECK-CTOR %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -o - -std=c++11 %s | FileCheck -check-prefix=CHECK-CTOR %s
// construct // construct
struct E { struct E {
E(); E();
E(E&&); E(E&&);
}; };
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

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

// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fexceptions -fcxx-exceptions -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fexceptions -fcxx-exceptions -emit-llvm -o - %s | FileCheck %s
struct A { struct A {
~A(); ~A();
}; };
struct B { struct B {
~B() throw(int); ~B() throw(int);
}; };
▲ Show 20 Lines • Show All 170 Lines • Show Last 20 Lines

test/CXX/special/class.dtor/p9.cpp

// RUN: %clang_cc1 -fsyntax-only -cxx-abi itanium -verify %s // RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify %s
// RUN: %clang_cc1 -fsyntax-only -cxx-abi microsoft -DMSABI -verify %s // RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify %s
typedef typeof(sizeof(int)) size_t; typedef typeof(sizeof(int)) size_t;
// PR7803 // PR7803
namespace test0 { namespace test0 {
class A { class A {
public: public:
static void operator delete(void *p) {}; static void operator delete(void *p) {};
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

test/CodeGen/builtin-ms-noop.cpp

// RUN: %clang_cc1 -fms-extensions -triple i686-pc-win32 -cxx-abi itanium -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -fms-extensions -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck %s
class A { class A {
public: public:
~A() {} ~A() {}
}; };
void f() { void f() {
// CHECK: @_Z1fv // CHECK: @_Z1fv
// CHECK-NOT: call void @_ZN1AD1Ev // CHECK-NOT: call void @_ZN1AD1Ev
// CHECK: ret void // CHECK: ret void
__noop(A()); __noop(A());
}; };

test/CodeGen/captured-statements.c

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o %t // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm %s -o %t
// RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-GLOBALS // RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-GLOBALS
// RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-1 // RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-1
// RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-2 // RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-2
// RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-3 // RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-3
int foo(); int foo();
int global; int global;
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

test/CodeGen/cxx-default-arg.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o %t // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm %s -o %t
// Note-LABEL: define CLANG_GENERATE_KNOWN_GOOD and compile to generate code // Note-LABEL: define CLANG_GENERATE_KNOWN_GOOD and compile to generate code
// that makes all of the defaulted arguments explicit. The resulting // that makes all of the defaulted arguments explicit. The resulting
// byte code should be identical to the compilation without // byte code should be identical to the compilation without
// CLANG_GENERATE_KNOWN_GOOD. // CLANG_GENERATE_KNOWN_GOOD.
#ifdef CLANG_GENERATE_KNOWN_GOOD #ifdef CLANG_GENERATE_KNOWN_GOOD
# define DEFARG(...) __VA_ARGS__ # define DEFARG(...) __VA_ARGS__
#else #else
Show All 16 Lines

test/CodeGen/fp-contract-pragma.cpp

// RUN: %clang_cc1 -O3 -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -O3 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
// Is FP_CONTRACT is honored in a simple case? // Is FP_CONTRACT is honored in a simple case?
float fp_contract_1(float a, float b, float c) { float fp_contract_1(float a, float b, float c) {
// CHECK: _Z13fp_contract_1fff // CHECK: _Z13fp_contract_1fff
// CHECK: tail call float @llvm.fmuladd // CHECK: tail call float @llvm.fmuladd
#pragma STDC FP_CONTRACT ON #pragma STDC FP_CONTRACT ON
return a * b + c; return a * b + c;
} }
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/CodeGen/mangle-windows.c

// RUN: %clang_cc1 -emit-llvm %s -o - -cxx-abi microsoft \ // RUN: %clang_cc1 -emit-llvm %s -o - triple=i386-pc-win32 | FileCheck %s
// RUN: -triple=i386-pc-win32 | FileCheck %s
// RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-mingw32 | FileCheck %s // RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-mingw32 | FileCheck %s
void __stdcall f1(void) {} void __stdcall f1(void) {}
// CHECK: define x86_stdcallcc void @"\01_f1@0" // CHECK: define x86_stdcallcc void @"\01_f1@0"
void __fastcall f2(void) {} void __fastcall f2(void) {}
// CHECK: define x86_fastcallcc void @"\01@f2@0" // CHECK: define x86_fastcallcc void @"\01@f2@0"
Show All 24 Lines

test/CodeGen/overloadable.c

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o - | grep _Z1fPA10_1X // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck %s
// CHECK: _Z1fPA10_1X
int __attribute__((overloadable)) f(int x) { return x; } int __attribute__((overloadable)) f(int x) { return x; }
float __attribute__((overloadable)) f(float x) { return x; } float __attribute__((overloadable)) f(float x) { return x; }
double __attribute__((overloadable)) f(double x) { return x; } double __attribute__((overloadable)) f(double x) { return x; }
double _Complex __attribute__((overloadable)) f(double _Complex x) { return x; } double _Complex __attribute__((overloadable)) f(double _Complex x) { return x; }
typedef short v4hi __attribute__ ((__vector_size__ (8))); typedef short v4hi __attribute__ ((__vector_size__ (8)));
v4hi __attribute__((overloadable)) f(v4hi x) { return x; } v4hi __attribute__((overloadable)) f(v4hi x) { return x; }
struct X { }; struct X { };
Show All 17 Lines

test/CodeGen/tbaa-for-vptr.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - -fsanitize=thread %s | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -o - -fsanitize=thread %s | FileCheck %s
// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - -O1 %s | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -o - -O1 %s | FileCheck %s
// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - -O1 -relaxed-aliasing -fsanitize=thread %s | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -o - -O1 -relaxed-aliasing -fsanitize=thread %s | FileCheck %s
// //
// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s --check-prefix=NOTBAA // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s --check-prefix=NOTBAA
// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - -O2 -relaxed-aliasing %s | FileCheck %s --check-prefix=NOTBAA // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -o - -O2 -relaxed-aliasing %s | FileCheck %s --check-prefix=NOTBAA
// //
// Check that we generate TBAA for vtable pointer loads and stores. // Check that we generate TBAA for vtable pointer loads and stores.
// When -fthread-sanitizer is used TBAA should be generated at all opt levels // When -fthread-sanitizer is used TBAA should be generated at all opt levels
// even if -relaxed-aliasing is present. // even if -relaxed-aliasing is present.
struct A { struct A {
virtual int foo() const ; virtual int foo() const ;
virtual ~A(); virtual ~A();
}; };
Show All 14 Lines

test/CodeGen/tbaa-ms-abi.cpp

// RUN: %clang_cc1 -cxx-abi microsoft -triple i686-pc-win32 -disable-llvm-optzns -emit-llvm -o - -O1 %s | FileCheck %s // RUN: %clang_cc1 -triple i686-pc-win32 -disable-llvm-optzns -emit-llvm -o - -O1 %s | FileCheck %s
// //
// Test that TBAA works in the Microsoft C++ ABI. We used to error out while // Test that TBAA works in the Microsoft C++ ABI. We used to error out while
// attempting to mangle RTTI. // attempting to mangle RTTI.
struct StructA { struct StructA {
int a; int a;
}; };
Show All 13 Lines

test/CodeGenCUDA/filter-decl.cu

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-HOST %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-HOST %s
// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o - -fcuda-is-device | FileCheck -check-prefix=CHECK-DEVICE %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm %s -o - -fcuda-is-device | FileCheck -check-prefix=CHECK-DEVICE %s
#include "../SemaCUDA/cuda.h" #include "../SemaCUDA/cuda.h"
// CHECK-HOST-NOT: constantdata = global // CHECK-HOST-NOT: constantdata = global
// CHECK-DEVICE: constantdata = global // CHECK-DEVICE: constantdata = global
__constant__ char constantdata[256]; __constant__ char constantdata[256];
// CHECK-HOST-NOT: devicedata = global // CHECK-HOST-NOT: devicedata = global
Show All 30 Lines

test/CodeGenCXX/2003-11-27-MultipleInheritanceThunk.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o - // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm %s -o -
// RUN: %clang_cc1 -cxx-abi microsoft -fno-rtti -emit-llvm %s -o - // RUN: %clang_cc1 -triple %ms_abi_triple -fno-rtti -emit-llvm %s -o -
struct CallSite { struct CallSite {
int X; int X;
CallSite(const CallSite &CS); CallSite(const CallSite &CS);
}; };
Show All 19 Lines

test/CodeGenCXX/2004-03-08-ReinterpretCastCopy.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o - // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm %s -o -
// FIXME: Don't assert for non-Win32 triples (PR18251). // FIXME: Don't assert for non-Win32 triples (PR18251).
// RUN: %clang_cc1 -triple i686-pc-win32 -cxx-abi microsoft -fno-rtti -emit-llvm %s -o - // RUN: %clang_cc1 -triple i686-pc-win32 -fno-rtti -emit-llvm %s -o -
struct A { struct A {
virtual void Method() = 0; virtual void Method() = 0;
}; };
struct B : public A { struct B : public A {
virtual void Method() { } virtual void Method() { }
}; };
Show All 12 Lines

test/CodeGenCXX/2004-03-09-UnmangledBuiltinMethods.cpp

// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -o - %s | FileCheck %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -o - %s | FileCheck %s
// CHECK: _ZN11AccessFlags6strlenEv // CHECK: _ZN11AccessFlags6strlenEv
struct AccessFlags { struct AccessFlags {
void strlen(); void strlen();
}; };
void AccessFlags::strlen() { } void AccessFlags::strlen() { }

test/CodeGenCXX/2006-09-12-OpaqueStructCrash.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -o - %s
// RUN: %clang_cc1 -cxx-abi microsoft -fno-rtti -emit-llvm -o - %s // RUN: %clang_cc1 -triple %ms_abi_triple -fno-rtti -emit-llvm -o - %s
struct A { struct A {
virtual ~A(); virtual ~A();
}; };
template <typename Ty> template <typename Ty>
struct B : public A { struct B : public A {
~B () { delete [] val; } ~B () { delete [] val; }
Show All 18 Lines

test/CodeGenCXX/2010-05-11-alwaysinlineinstantiation.cpp

// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium %s -o - | FileCheck %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple %s -o - | FileCheck %s
// CHECK-NOT: ZN12basic_stringIcEC1Ev // CHECK-NOT: ZN12basic_stringIcEC1Ev
// CHECK: ZN12basic_stringIcED1Ev // CHECK: ZN12basic_stringIcED1Ev
// CHECK: ZN12basic_stringIcED1Ev // CHECK: ZN12basic_stringIcED1Ev
template<class charT> template<class charT>
class basic_string class basic_string
{ {
public: public:
Show All 24 Lines

test/CodeGenCXX/PR5093-static-member-function.cpp

// RUN: %clang_cc1 %s -emit-llvm -cxx-abi itanium -o - | FileCheck %s // RUN: %clang_cc1 %s -emit-llvm -triple %itanium_abi_triple -o - | FileCheck %s
struct a { struct a {
static void f(); static void f();
}; };
void g(a *a) { void g(a *a) {
// CHECK: call void @_ZN1a1fEv() // CHECK: call void @_ZN1a1fEv()
a->f(); a->f();
} }

test/CodeGenCXX/PR5863-unreachable-block.cpp

// RUN: %clang_cc1 -cxx-abi itanium -fcxx-exceptions -fexceptions -emit-llvm-only %s // RUN: %clang_cc1 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -emit-llvm-only %s
// PR5863 // PR5863
class E { }; class E { };
void P1() { void P1() {
try { try {
int a=0, b=0; int a=0, b=0;
if (a > b) // simply filling in 0 or 1 doesn't trigger the assertion if (a > b) // simply filling in 0 or 1 doesn't trigger the assertion
throw E(); // commenting out 'if' or 'throw' 'fixes' the assertion failure throw E(); // commenting out 'if' or 'throw' 'fixes' the assertion failure
try { } catch (...) { } // empty try/catch block needed for failure try { } catch (...) { } // empty try/catch block needed for failure
} catch (...) { } // this try/catch block needed for failure } catch (...) { } // this try/catch block needed for failure
} }

test/CodeGenCXX/address-of-fntemplate.cpp

// RUN: %clang_cc1 %s -emit-llvm -cxx-abi itanium -o - | FileCheck %s // RUN: %clang_cc1 %s -emit-llvm -triple %itanium_abi_triple -o - | FileCheck %s
template <typename T> void f(T) {} template <typename T> void f(T) {}
template <typename T> void f() { } template <typename T> void f() { }
void test() { void test() {
// CHECK: @_Z1fIiEvT_ // CHECK: @_Z1fIiEvT_
void (*p)(int) = &f; void (*p)(int) = &f;
// CHECK: @_Z1fIiEvv // CHECK: @_Z1fIiEvv
Show All 18 Lines

test/CodeGenCXX/attr-cleanup.cpp

// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -o - %s | FileCheck %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -o - %s | FileCheck %s
namespace N { namespace N {
void free(void *i) {} void free(void *i) {}
} }
int main(void) { int main(void) {
// CHECK: call void @_ZN1N4freeEPv // CHECK: call void @_ZN1N4freeEPv
void *fp __attribute__((cleanup(N::free))); void *fp __attribute__((cleanup(N::free)));
return 0; return 0;
} }

test/CodeGenCXX/attr-used.cpp

// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -o - %s | FileCheck %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -o - %s | FileCheck %s
// <rdar://problem/8684363>: clang++ not respecting __attribute__((used)) on destructors // <rdar://problem/8684363>: clang++ not respecting __attribute__((used)) on destructors
struct X0 { struct X0 {
// CHECK: define linkonce_odr {{.*}} @_ZN2X0C1Ev // CHECK: define linkonce_odr {{.*}} @_ZN2X0C1Ev
__attribute__((used)) X0() {} __attribute__((used)) X0() {}
// CHECK: define linkonce_odr {{.*}} @_ZN2X0D1Ev // CHECK: define linkonce_odr {{.*}} @_ZN2X0D1Ev
__attribute__((used)) ~X0() {} __attribute__((used)) ~X0() {}
}; };

test/CodeGenCXX/block-byref-cxx-objc.cpp

// RUN: %clang_cc1 %s -emit-llvm -cxx-abi itanium -o - -fblocks | FileCheck %s // RUN: %clang_cc1 %s -emit-llvm -triple %itanium_abi_triple -o - -fblocks | FileCheck %s
// rdar://8594790 // rdar://8594790
struct A { struct A {
int x; int x;
A(const A &); A(const A &);
A(); A();
~A(); ~A();
}; };
Show All 26 Lines

test/CodeGenCXX/block.cpp

// RUN: %clang_cc1 %s -cxx-abi itanium -emit-llvm -o - -fblocks // RUN: %clang_cc1 %s -triple %itanium_abi_triple -emit-llvm -o - -fblocks
// RUN: %clang_cc1 %s -cxx-abi microsoft -fno-rtti -emit-llvm -o - -fblocks // RUN: %clang_cc1 %s -triple %ms_abi_triple -fno-rtti -emit-llvm -o - -fblocks
// Just test that this doesn't crash the compiler... // Just test that this doesn't crash the compiler...
void func(void*); void func(void*);
struct Test struct Test
{ {
virtual void use() { func((void*)this); } virtual void use() { func((void*)this); }
Test(Test&c) { func((void*)this); } Test(Test&c) { func((void*)this); }
Show All 10 Lines

test/CodeGenCXX/c-linkage.cpp

// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -o - %s | FileCheck %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -o - %s | FileCheck %s
// pr6644 // pr6644
extern "C" { extern "C" {
namespace N { namespace N {
struct X { struct X {
virtual void f(); virtual void f();
}; };
void X::f() { } void X::f() { }
Show All 24 Lines

test/CodeGenCXX/captured-statements.cpp

// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -emit-llvm %s -o %t // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -emit-llvm %s -o %t
// RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-1 // RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-1
// RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-2 // RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-2
// RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-3 // RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-3
// RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-4 // RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-4
// RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-5 // RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-5
// RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-6 // RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-6
// RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-7 // RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-7
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

test/CodeGenCXX/const-base-cast.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck %s
// Check that the following construct, which is similar to one which occurs // Check that the following construct, which is similar to one which occurs
// in Firefox, is folded correctly. // in Firefox, is folded correctly.
struct A { char x; }; struct A { char x; };
struct B { char y; }; struct B { char y; };
struct C : A,B {}; struct C : A,B {};
unsigned char x = ((char*)(B*)(C*)0x1000) - (char*)0x1000; unsigned char x = ((char*)(B*)(C*)0x1000) - (char*)0x1000;
// CHECK: @x = global i8 1 // CHECK: @x = global i8 1

test/CodeGenCXX/const-global-linkage.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
const int x = 10; const int x = 10;
const int y = 20; const int y = 20;
const volatile int z = 30; const volatile int z = 30;
// CHECK-NOT: @x // CHECK-NOT: @x
// CHECK: @z = constant i32 30 // CHECK: @z = constant i32 30
// CHECK: @_ZL1y = internal constant i32 20 // CHECK: @_ZL1y = internal constant i32 20
const int& b() { return y; } const int& b() { return y; }
const char z1[] = "asdf"; const char z1[] = "asdf";
const char z2[] = "zxcv"; const char z2[] = "zxcv";
const volatile char z3[] = "zxcv"; const volatile char z3[] = "zxcv";
// CHECK-NOT: @z1 // CHECK-NOT: @z1
// CHECK: @z3 = constant // CHECK: @z3 = constant
// CHECK: @_ZL2z2 = internal constant // CHECK: @_ZL2z2 = internal constant
const char* b2() { return z2; } const char* b2() { return z2; }

test/CodeGenCXX/constructor-attr.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
// CHECK: @llvm.global_ctors // CHECK: @llvm.global_ctors
// PR6521 // PR6521
void bar(); void bar();
struct Foo { struct Foo {
// CHECK-LABEL: define linkonce_odr void @_ZN3Foo3fooEv // CHECK-LABEL: define linkonce_odr void @_ZN3Foo3fooEv
static void foo() __attribute__((constructor)) { static void foo() __attribute__((constructor)) {
bar(); bar();
} }
}; };

test/CodeGenCXX/constructor-destructor-return-this.cpp

//RUN: %clang_cc1 %s -emit-llvm -o - -triple=i686-unknown-linux | FileCheck --check-prefix=CHECKGEN %s //RUN: %clang_cc1 %s -emit-llvm -o - -triple=i686-unknown-linux | FileCheck --check-prefix=CHECKGEN %s
//RUN: %clang_cc1 %s -emit-llvm -o - -triple=thumbv7-apple-ios3.0 -target-abi apcs-gnu | FileCheck --check-prefix=CHECKARM %s //RUN: %clang_cc1 %s -emit-llvm -o - -triple=thumbv7-apple-ios3.0 -target-abi apcs-gnu | FileCheck --check-prefix=CHECKARM %s
//RUN: %clang_cc1 %s -emit-llvm -o - -triple=i386-pc-win32 -cxx-abi microsoft -fno-rtti | FileCheck --check-prefix=CHECKMS %s //RUN: %clang_cc1 %s -emit-llvm -o - -triple=i386-pc-win32 -fno-rtti | FileCheck --check-prefix=CHECKMS %s
// FIXME: these tests crash on the bots when run with -triple=x86_64-pc-win32 // FIXME: these tests crash on the bots when run with -triple=x86_64-pc-win32
// Make sure we attach the 'returned' attribute to the 'this' parameter of // Make sure we attach the 'returned' attribute to the 'this' parameter of
// constructors and destructors which return this (and only these cases) // constructors and destructors which return this (and only these cases)
class A { class A {
public: public:
A(); A();
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

test/CodeGenCXX/constructor-init-reference.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
int x; int x;
struct A { struct A {
int& y; int& y;
A() : y(x) {} A() : y(x) {}
}; };
A z; A z;
// CHECK: store i32* @x, i32** // CHECK: store i32* @x, i32**

test/CodeGenCXX/copy-assign-synthesis-2.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck %s
struct A {}; struct A {};
A& (A::*x)(const A&) = &A::operator=; A& (A::*x)(const A&) = &A::operator=;
// CHECK-LABEL: define linkonce_odr {{.*}}%struct.A* @_ZN1AaSERKS_ // CHECK-LABEL: define linkonce_odr {{.*}}%struct.A* @_ZN1AaSERKS_

test/CodeGenCXX/copy-constructor-synthesis-2.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
struct A { virtual void a(); }; struct A { virtual void a(); };
A x(A& y) { return y; } A x(A& y) { return y; }
// CHECK: define linkonce_odr {{.*}} @_ZN1AC1ERKS_(%struct.A* {{.*}}%this, %struct.A*) unnamed_addr // CHECK: define linkonce_odr {{.*}} @_ZN1AC1ERKS_(%struct.A* {{.*}}%this, %struct.A*) unnamed_addr
// CHECK: store i8** getelementptr inbounds ([3 x i8*]* @_ZTV1A, i64 0, i64 2) // CHECK: store i8** getelementptr inbounds ([3 x i8*]* @_ZTV1A, i64 0, i64 2)

test/CodeGenCXX/coverage.cpp

// RUN: %clang_cc1 %s -cxx-abi itanium -emit-llvm -o - -test-coverage -femit-coverage-notes | FileCheck %s // RUN: %clang_cc1 %s -triple %itanium_abi_triple -emit-llvm -o - -test-coverage -femit-coverage-notes | FileCheck %s
extern "C" void test_name1() {} extern "C" void test_name1() {}
void test_name2() {} void test_name2() {}
// CHECK: metadata !"test_name1", metadata !"test_name1", metadata !"",{{.*}}DW_TAG_subprogram // CHECK: metadata !"test_name1", metadata !"test_name1", metadata !"",{{.*}}DW_TAG_subprogram
// CHECK: metadata !"test_name2", metadata !"test_name2", metadata !"_Z10test_name2v",{{.*}}DW_TAG_subprogram // CHECK: metadata !"test_name2", metadata !"test_name2", metadata !"_Z10test_name2v",{{.*}}DW_TAG_subprogram

test/CodeGenCXX/cxx0x-defaulted-templates.cpp

// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
template <typename T> template <typename T>
struct X { struct X {
X(); X();
}; };
// CHECK: define {{.*}} @_ZN1XIbEC2Ev // CHECK: define {{.*}} @_ZN1XIbEC2Ev
// CHECK: define {{.*}} @_ZN1XIbEC1Ev // CHECK: define {{.*}} @_ZN1XIbEC1Ev
Show All 10 Lines

test/CodeGenCXX/cxx11-noreturn.cpp

// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -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]] = { noreturn nounwind{{.*}} } // CHECK: attributes [[NR]] = { noreturn nounwind{{.*}} }

test/CodeGenCXX/cxx11-unrestricted-union.cpp

// RUN: %clang_cc1 -cxx-abi itanium -std=c++11 -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 -emit-llvm %s -o - | FileCheck %s
struct A { struct A {
A(); A(const A&); A(A&&); A &operator=(const A&); A &operator=(A&&); ~A(); A(); A(const A&); A(A&&); A &operator=(const A&); A &operator=(A&&); ~A();
}; };
struct B { struct B {
B(); B(const B&); B(B&&); B &operator=(const B&); B &operator=(B&&); ~B(); B(); B(const B&); B(B&&); B &operator=(const B&); B &operator=(B&&); ~B();
}; };
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

test/CodeGenCXX/debug-info-char16.cpp

// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -std=c++11 -g %s -o -| FileCheck %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -std=c++11 -g %s -o -| FileCheck %s
// 16 is DW_ATE_UTF (0x10) encoding attribute. // 16 is DW_ATE_UTF (0x10) encoding attribute.
char16_t char_a = u'h'; char16_t char_a = u'h';
// CHECK: !{{.*}} = {{.*}} ; [ DW_TAG_base_type ] [char16_t] // CHECK: !{{.*}} = {{.*}} ; [ DW_TAG_base_type ] [char16_t]

test/CodeGenCXX/debug-info-enum.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -g %s -o - | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -g %s -o - | FileCheck %s
// CHECK: [[ENUMS:![0-9]*]], {{[^,]*}}, {{[^,]*}}, {{[^,]*}}, {{[^,]*}}, {{[^,]*}}} ; [ DW_TAG_compile_unit ] // CHECK: [[ENUMS:![0-9]*]], {{[^,]*}}, {{[^,]*}}, {{[^,]*}}, {{[^,]*}}, {{[^,]*}}} ; [ DW_TAG_compile_unit ]
// CHECK: [[ENUMS]] = metadata !{metadata [[E1:![0-9]*]], metadata [[E2:![0-9]*]], metadata [[E3:![0-9]*]]} // CHECK: [[ENUMS]] = metadata !{metadata [[E1:![0-9]*]], metadata [[E2:![0-9]*]], metadata [[E3:![0-9]*]]}
namespace test1 { namespace test1 {
// CHECK: [[E1]] = metadata !{i32 {{[^,]*}}, {{[^,]*}}, metadata [[TEST1:![0-9]*]], {{.*}}, metadata [[TEST1_ENUMS:![0-9]*]], {{[^,]*}}, null, null, metadata !"_ZTSN5test11eE"} ; [ DW_TAG_enumeration_type ] [e] // CHECK: [[E1]] = metadata !{i32 {{[^,]*}}, {{[^,]*}}, metadata [[TEST1:![0-9]*]], {{.*}}, metadata [[TEST1_ENUMS:![0-9]*]], {{[^,]*}}, null, null, metadata !"_ZTSN5test11eE"} ; [ DW_TAG_enumeration_type ] [e]
// CHECK: [[TEST1]] = {{.*}} ; [ DW_TAG_namespace ] [test1] // CHECK: [[TEST1]] = {{.*}} ; [ DW_TAG_namespace ] [test1]
// CHECK: [[TEST1_ENUMS]] = metadata !{metadata [[TEST1_E:![0-9]*]]} // CHECK: [[TEST1_ENUMS]] = metadata !{metadata [[TEST1_E:![0-9]*]]}
Show All 27 Lines

test/CodeGenCXX/debug-info-global-ctor-dtor.cpp

// RUN: %clang_cc1 %s -g -cxx-abi itanium -fno-use-cxa-atexit -S -emit-llvm -o - \ // RUN: %clang_cc1 %s -g -triple %itanium_abi_triple -fno-use-cxa-atexit -S -emit-llvm -o - \
// RUN: | FileCheck %s --check-prefix=CHECK-NOKEXT // RUN: | FileCheck %s --check-prefix=CHECK-NOKEXT
// RUN: %clang_cc1 %s -g -cxx-abi itanium -fno-use-cxa-atexit -fapple-kext -S -emit-llvm -o - \ // RUN: %clang_cc1 %s -g -triple %itanium_abi_triple -fno-use-cxa-atexit -fapple-kext -S -emit-llvm -o - \
// RUN: | FileCheck %s --check-prefix=CHECK-KEXT // RUN: | FileCheck %s --check-prefix=CHECK-KEXT
class A { class A {
public: public:
A() {} A() {}
virtual ~A() {} virtual ~A() {}
}; };
Show All 16 Lines

test/CodeGenCXX/debug-info-method.cpp

// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -std=c++11 -g %s -o - | FileCheck %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -std=c++11 -g %s -o - | FileCheck %s
// CHECK: metadata !"_ZTS1A"} ; [ DW_TAG_class_type ] [A] // CHECK: metadata !"_ZTS1A"} ; [ DW_TAG_class_type ] [A]
// CHECK: metadata !"_ZN1A3fooEiS_3$_0", {{.*}} [protected] // CHECK: metadata !"_ZN1A3fooEiS_3$_0", {{.*}} [protected]
// CHECK: ![[THISTYPE:[0-9]+]] = {{.*}} ; [ DW_TAG_pointer_type ] {{.*}} [artificial] [from _ZTS1A] // CHECK: ![[THISTYPE:[0-9]+]] = {{.*}} ; [ DW_TAG_pointer_type ] {{.*}} [artificial] [from _ZTS1A]
// CHECK: DW_TAG_ptr_to_member_type // CHECK: DW_TAG_ptr_to_member_type
// CHECK: {{.*}}metadata ![[MEMFUNTYPE:[0-9]+]], metadata !{{.*}}} ; [ DW_TAG_ptr_to_member_type ] {{.*}} [from ] // CHECK: {{.*}}metadata ![[MEMFUNTYPE:[0-9]+]], metadata !{{.*}}} ; [ DW_TAG_ptr_to_member_type ] {{.*}} [from ]
// CHECK: ![[MEMFUNTYPE]] = {{.*}}metadata ![[MEMFUNARGS:[0-9]+]], i32 0, null, null, null} ; [ DW_TAG_subroutine_type ] {{.*}} [from ] // CHECK: ![[MEMFUNTYPE]] = {{.*}}metadata ![[MEMFUNARGS:[0-9]+]], i32 0, null, null, null} ; [ DW_TAG_subroutine_type ] {{.*}} [from ]
// CHECK: ![[MEMFUNARGS]] = {{.*}}, metadata ![[THISTYPE]], // CHECK: ![[MEMFUNARGS]] = {{.*}}, metadata ![[THISTYPE]],
// CHECK: ""{{.*}}DW_TAG_arg_variable // CHECK: ""{{.*}}DW_TAG_arg_variable
Show All 19 Lines

test/CodeGenCXX/debug-info-same-line.cpp

// RUN: %clang_cc1 -g -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -g -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
// Make sure that clang outputs distinct debug info for a function // Make sure that clang outputs distinct debug info for a function
// that is inlined twice on the same line. Otherwise it would appear // that is inlined twice on the same line. Otherwise it would appear
// as if the function was only inlined once. // as if the function was only inlined once.
#define INLINE inline __attribute__((always_inline)) #define INLINE inline __attribute__((always_inline))
INLINE int INLINE int
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

test/CodeGenCXX/debug-info-template-limit.cpp

// RUN: %clang_cc1 -emit-llvm -fno-standalone-debug -cxx-abi itanium -g %s -o - | FileCheck %s // RUN: %clang_cc1 -emit-llvm -fno-standalone-debug -triple %itanium_abi_triple -g %s -o - | FileCheck %s
// Check that this pointer type is TC<int> // Check that this pointer type is TC<int>
// CHECK: ![[LINE:[0-9]+]] = {{.*}}"TC<int>", {{.*}} metadata !"_ZTS2TCIiE"} ; [ DW_TAG_class_type ] // CHECK: ![[LINE:[0-9]+]] = {{.*}}"TC<int>", {{.*}} metadata !"_ZTS2TCIiE"} ; [ DW_TAG_class_type ]
// CHECK: metadata !"_ZTS2TCIiE"} ; [ DW_TAG_pointer_type ]{{.*}}[from _ZTS2TCIiE] // CHECK: metadata !"_ZTS2TCIiE"} ; [ DW_TAG_pointer_type ]{{.*}}[from _ZTS2TCIiE]
template<typename T> template<typename T>
class TC { class TC {
public: public:
TC(const TC &) {} TC(const TC &) {}
TC() {} TC() {}
}; };
TC<int> tci; TC<int> tci;

test/CodeGenCXX/debug-info-thunk.cpp

// RUN: %clang_cc1 %s -cxx-abi itanium -g -S -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -triple %itanium_abi_triple -g -S -emit-llvm -o - | FileCheck %s
struct A { struct A {
virtual void f(); virtual void f();
}; };
struct B { struct B {
virtual void f(); virtual void f();
}; };
struct C : A, B { struct C : A, B {
virtual void f(); virtual void f();
}; };
void C::f() { } void C::f() { }
// CHECK: metadata !"_ZThn{{4|8}}_N1C1fEv", i32 15, {{.*}} ; [ DW_TAG_subprogram ] [line 15] [def]{{$}} // CHECK: metadata !"_ZThn{{4|8}}_N1C1fEv", i32 15, {{.*}} ; [ DW_TAG_subprogram ] [line 15] [def]{{$}}

test/CodeGenCXX/debug-info-use-after-free.cpp

// RUN: %clang_cc1 -g -cxx-abi itanium -emit-llvm-only %s // RUN: %clang_cc1 -g -triple %itanium_abi_triple -emit-llvm-only %s
// Check that we don't crash. // Check that we don't crash.
// PR12305, PR12315 // PR12305, PR12315
# 1 "a.h" 3 # 1 "a.h" 3
template < typename T1 > struct Types1 template < typename T1 > struct Types1
{ {
typedef T1 Head; typedef T1 Head;
}; };
▲ Show 20 Lines • Show All 304 Lines • Show Last 20 Lines

test/CodeGenCXX/debug-info-uuid.cpp

// RUN: %clang_cc1 -emit-llvm -fms-extensions -triple=x86_64-pc-win32 -cxx-abi microsoft -g %s -o - -std=c++11 | FileCheck %s // RUN: %clang_cc1 -emit-llvm -fms-extensions -triple=x86_64-pc-win32 -g %s -o - -std=c++11 | FileCheck %s
// RUN: not %clang_cc1 -emit-llvm -fms-extensions -triple=x86_64-unknown-unknown -g %s -o - -std=c++11 2>&1 | FileCheck %s --check-prefix=CHECK-ITANIUM // RUN: not %clang_cc1 -emit-llvm -fms-extensions -triple=x86_64-unknown-unknown -g %s -o - -std=c++11 2>&1 | FileCheck %s --check-prefix=CHECK-ITANIUM
// CHECK: metadata [[TGIARGS:![0-9]*]], null} ; [ DW_TAG_structure_type ] [tmpl_guid<&__uuidof(uuid)>] // CHECK: metadata [[TGIARGS:![0-9]*]], null} ; [ DW_TAG_structure_type ] [tmpl_guid<&__uuidof(uuid)>]
// CHECK: [[TGIARGS]] = metadata !{metadata [[TGIARG1:![0-9]*]]} // CHECK: [[TGIARGS]] = metadata !{metadata [[TGIARG1:![0-9]*]]}
// CHECK: [[TGIARG1]] = {{.*}}metadata !"", metadata [[CONST_GUID_PTR:![0-9]*]], { i32, i16, i16, [8 x i8] }* @_GUID_12345678_1234_1234_1234_1234567890ab, {{.*}} ; [ DW_TAG_template_value_parameter ] // CHECK: [[TGIARG1]] = {{.*}}metadata !"", metadata [[CONST_GUID_PTR:![0-9]*]], { i32, i16, i16, [8 x i8] }* @_GUID_12345678_1234_1234_1234_1234567890ab, {{.*}} ; [ DW_TAG_template_value_parameter ]
// CHECK: [[CONST_GUID_PTR]] = {{.*}}, metadata [[CONST_GUID:![0-9]*]]} ; [ DW_TAG_pointer_type ] [line 0, size 64, align 64, offset 0] [from ] // CHECK: [[CONST_GUID_PTR]] = {{.*}}, metadata [[CONST_GUID:![0-9]*]]} ; [ DW_TAG_pointer_type ] [line 0, size 64, align 64, offset 0] [from ]
// CHECK: [[CONST_GUID]] = {{.*}}, metadata [[GUID:![0-9]*]]} ; [ DW_TAG_const_type ] [line 0, size 0, align 0, offset 0] [from _GUID] // CHECK: [[CONST_GUID]] = {{.*}}, metadata [[GUID:![0-9]*]]} ; [ DW_TAG_const_type ] [line 0, size 0, align 0, offset 0] [from _GUID]
// CHECK: [[GUID]] = {{.*}} ; [ DW_TAG_structure_type ] [_GUID] // CHECK: [[GUID]] = {{.*}} ; [ DW_TAG_structure_type ] [_GUID]
Show All 10 Lines

test/CodeGenCXX/default-constructor-default-argument.cpp

// RUN: %clang_cc1 %s -cxx-abi itanium -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
// Check that call to constructor for struct A is generated correctly. // Check that call to constructor for struct A is generated correctly.
struct A { A(int x = 2); }; struct A { A(int x = 2); };
struct B : public A {}; struct B : public A {};
B x; B x;
// CHECK: call {{.*}} @_ZN1AC2Ei // CHECK: call {{.*}} @_ZN1AC2Ei

test/CodeGenCXX/default-constructor-template-member.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck %s
template <class T> struct A { A(); }; template <class T> struct A { A(); };
struct B { A<int> x; }; struct B { A<int> x; };
void a() { void a() {
B b; B b;
} }
// CHECK: call {{.*}} @_ZN1BC1Ev // CHECK: call {{.*}} @_ZN1BC1Ev
// CHECK: define linkonce_odr {{.*}} @_ZN1BC1Ev(%struct.B* {{.*}}%this) unnamed_addr // CHECK: define linkonce_odr {{.*}} @_ZN1BC1Ev(%struct.B* {{.*}}%this) unnamed_addr
// CHECK: call {{.*}} @_ZN1AIiEC1Ev // CHECK: call {{.*}} @_ZN1AIiEC1Ev

test/CodeGenCXX/default-destructor-nested.cpp

// RUN: %clang_cc1 %s -cxx-abi itanium -emit-llvm-only // RUN: %clang_cc1 %s -triple %itanium_abi_triple -emit-llvm-only
// PR6294 // PR6294
class A { class A {
public: virtual ~A(); public: virtual ~A();
}; };
class B { class B {
class C; class C;
}; };
class B::C : public A { class B::C : public A {
C(); C();
}; };
B::C::C() {} B::C::C() {}

test/CodeGenCXX/deferred-global-init.cpp

// RUN: %clang_cc1 %s -cxx-abi itanium -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
// PR5967 // PR5967
extern void* foo; extern void* foo;
static void* const a = foo; static void* const a = foo;
void* bar() { return a; } void* bar() { return a; }
// CHECK: @_ZL1a = internal global i8* null // CHECK: @_ZL1a = internal global i8* null
// CHECK-LABEL: define internal void @__cxx_global_var_init // CHECK-LABEL: define internal void @__cxx_global_var_init
// CHECK: load i8** @foo // CHECK: load i8** @foo
// CHECK: ret void // CHECK: ret void
// CHECK-LABEL: define internal void @_GLOBAL__I_a // CHECK-LABEL: define internal void @_GLOBAL__I_a
// CHECK: call void @__cxx_global_var_init() // CHECK: call void @__cxx_global_var_init()
// CHECK: ret void // CHECK: ret void

test/CodeGenCXX/delayed-template-parsing.cpp

// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -cxx-abi microsoft -fms-extensions -fdelayed-template-parsing -triple=i386-pc-win32 | FileCheck %s // RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -fms-extensions -fdelayed-template-parsing -triple=i386-pc-win32 | FileCheck %s
// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -cxx-abi microsoft -fms-extensions -fdelayed-template-parsing -triple=x86_64-pc-win32 | FileCheck -check-prefix X64 %s // RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -fms-extensions -fdelayed-template-parsing -triple=x86_64-pc-win32 | FileCheck -check-prefix X64 %s
namespace ClassScopeSpecialization { namespace ClassScopeSpecialization {
struct Type { struct Type {
template <int i> template <int i>
void Foo() {} void Foo() {}
template <> template <>
void Foo<0>() {} void Foo<0>() {}
}; };
void call() { void call() {
Type T; Type T;
// CHECK: call {{.*}} @"\01??$Foo@$0A@@Type@ClassScopeSpecialization@@QAEXXZ" // CHECK: call {{.*}} @"\01??$Foo@$0A@@Type@ClassScopeSpecialization@@QAEXXZ"
// X64: call {{.*}} @"\01??$Foo@$0A@@Type@ClassScopeSpecialization@@QEAAXXZ" // X64: call {{.*}} @"\01??$Foo@$0A@@Type@ClassScopeSpecialization@@QEAAXXZ"
T.Foo<0>(); T.Foo<0>();
} }
} }

test/CodeGenCXX/derived-to-virtual-base-class-calls-final.cpp

// RUN: %clang_cc1 %s -cxx-abi itanium -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
struct A { int i; }; struct A { int i; };
struct B { char j; }; struct B { char j; };
struct C : A, B { int k; }; struct C : A, B { int k; };
struct D final : virtual C { struct D final : virtual C {
D(); D();
virtual void f(); virtual void f();
}; };
// CHECK-LABEL: define %struct.B* @_Z1fR1D // CHECK-LABEL: define %struct.B* @_Z1fR1D
B &f(D &d) { B &f(D &d) {
// CHECK-NOT: load i8** // CHECK-NOT: load i8**
return d; return d;
} }

test/CodeGenCXX/destructor-exception-spec.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm-only %s -std=c++11 // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm-only %s -std=c++11
// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm-only -fno-use-cxa-atexit %s -std=c++11 // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm-only -fno-use-cxa-atexit %s -std=c++11
// RUN: %clang_cc1 -cxx-abi microsoft -fno-rtti -emit-llvm-only %s -std=c++11 // RUN: %clang_cc1 -triple %ms_abi_triple -fno-rtti -emit-llvm-only %s -std=c++11
// PR13479: don't crash with -fno-exceptions. // PR13479: don't crash with -fno-exceptions.
namespace { namespace {
struct SchedulePostRATDList { struct SchedulePostRATDList {
virtual ~SchedulePostRATDList(); virtual ~SchedulePostRATDList();
}; };
SchedulePostRATDList::~SchedulePostRATDList() {} SchedulePostRATDList::~SchedulePostRATDList() {}
SchedulePostRATDList Scheduler; SchedulePostRATDList Scheduler;
} }

test/CodeGenCXX/duplicate-mangled-name.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm-only %s -verify // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm-only %s -verify
// rdar://15522601 // rdar://15522601
class MyClass { class MyClass {
static void meth(); static void meth();
}; };
void MyClass::meth() { } void MyClass::meth() { }
extern "C" { extern "C" {
void _ZN7MyClass4methEv() { } // expected-error {{definition with same mangled name as another definition}} void _ZN7MyClass4methEv() { } // expected-error {{definition with same mangled name as another definition}}
} }

test/CodeGenCXX/dynamic_cast-no-rtti.cpp

// RUN: %clang_cc1 -emit-llvm %s -verify -fno-rtti -cxx-abi itanium -o - | FileCheck %s // RUN: %clang_cc1 -emit-llvm %s -verify -fno-rtti -triple %itanium_abi_triple -o - | FileCheck %s
// expected-no-diagnostics // expected-no-diagnostics
struct A { struct A {
virtual ~A(){}; virtual ~A(){};
}; };
struct B : public A { struct B : public A {
B() : A() {} B() : A() {}
Show All 17 Lines

test/CodeGenCXX/elide-call-reference.cpp

// RUN: %clang_cc1 %s -emit-llvm -cxx-abi itanium -o - | FileCheck %s // RUN: %clang_cc1 %s -emit-llvm -triple %itanium_abi_triple -o - | FileCheck %s
// PR5695 // PR5695
struct A { A(const A&); ~A(); }; struct A { A(const A&); ~A(); };
A& a(); A& a();
void b() { void b() {
A x = a(); A x = a();
} }
// CHECK: call {{.*}} @_ZN1AC1ERKS_ // CHECK: call {{.*}} @_ZN1AC1ERKS_
// CHECK: call {{.*}} @_ZN1AD1Ev // CHECK: call {{.*}} @_ZN1AD1Ev

test/CodeGenCXX/extern-c.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck %s
namespace foo { namespace foo {
// CHECK-NOT: @a = global i32 // CHECK-NOT: @a = global i32
extern "C" int a; extern "C" int a;
// CHECK-NOT: @_ZN3foo1bE = global i32 // CHECK-NOT: @_ZN3foo1bE = global i32
extern int b; extern int b;
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

test/CodeGenCXX/function-template-explicit-specialization.cpp

// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium %s -o - | FileCheck %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple %s -o - | FileCheck %s
template<typename T> void a(T); template<typename T> void a(T);
template<> void a(int) {} template<> void a(int) {}
// CHECK-LABEL: define void @_Z1aIiEvT_ // CHECK-LABEL: define void @_Z1aIiEvT_
namespace X { namespace X {
template<typename T> void b(T); template<typename T> void b(T);
template<> void b(int) {} template<> void b(int) {}
} }
// CHECK-LABEL: define void @_ZN1X1bIiEEvT_ // CHECK-LABEL: define void @_ZN1X1bIiEEvT_

test/CodeGenCXX/function-template-specialization.cpp

// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium %s -o - | FileCheck %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple %s -o - | FileCheck %s
template<typename T, typename U> template<typename T, typename U>
T* next(T* ptr, const U& diff); T* next(T* ptr, const U& diff);
template<typename T, typename U> template<typename T, typename U>
T* next(T* ptr, const U& diff) { T* next(T* ptr, const U& diff) {
return ptr + diff; return ptr + diff;
} }
Show All 17 Lines

test/CodeGenCXX/global-llvm-constant.cpp

// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -o - %s | FileCheck %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -o - %s | FileCheck %s
struct A { struct A {
A() { x = 10; } A() { x = 10; }
int x; int x;
}; };
const A x; const A x;
Show All 23 Lines

test/CodeGenCXX/implicit-instantiation-1.cpp

// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium %s -o %t // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple %s -o %t
template<typename T> template<typename T>
struct X { struct X {
void f(T) { } void f(T) { }
void f(char) { } void f(char) { }
void g(T) { } void g(T) { }
Show All 19 Lines

test/CodeGenCXX/instr-profile.cpp

// Test that instrumentation based profiling feeds branch prediction // Test that instrumentation based profiling feeds branch prediction
// correctly. This tests both generation of profile data and use of the same, // correctly. This tests both generation of profile data and use of the same,
// and the input file for the -fprofile-instr-use case is expected to be result // and the input file for the -fprofile-instr-use case is expected to be result
// of running the program generated by the -fprofile-instr-generate case. As // of running the program generated by the -fprofile-instr-generate case. As
// such, main() should call every function in this test. // such, main() should call every function in this test.
// FIXME: Don't seek bb labels, like "if.else" // FIXME: Don't seek bb labels, like "if.else"
// REQUIRES: asserts // REQUIRES: asserts
// RUN: %clangxx %s -o - -emit-llvm -S -fprofile-instr-generate -Xclang -cxx-abi -Xclang itanium | FileCheck -check-prefix=PGOGEN %s // RUN: %clangxx %s -o - -emit-llvm -S -fprofile-instr-generate -target %itanium_abi_triple | FileCheck -check-prefix=PGOGEN %s
// RUN: %clangxx %s -o - -emit-llvm -S -fprofile-instr-generate -Xclang -cxx-abi -Xclang itanium | FileCheck -check-prefix=PGOGEN-EXC %s // RUN: %clangxx %s -o - -emit-llvm -S -fprofile-instr-generate -target %itanium_abi_triple | FileCheck -check-prefix=PGOGEN-EXC %s
// RUN: %clang %s -o - -emit-llvm -S -fprofile-instr-use=%S/Inputs/instr-profile.pgodata -Xclang -cxx-abi -Xclang itanium | FileCheck -check-prefix=PGOUSE %s // RUN: %clang %s -o - -emit-llvm -S -fprofile-instr-use=%S/Inputs/instr-profile.pgodata -target %itanium_abi_triple | FileCheck -check-prefix=PGOUSE %s
// RUN: %clang %s -o - -emit-llvm -S -fprofile-instr-use=%S/Inputs/instr-profile.pgodata -Xclang -cxx-abi -Xclang itanium | FileCheck -check-prefix=PGOUSE-EXC %s // RUN: %clang %s -o - -emit-llvm -S -fprofile-instr-use=%S/Inputs/instr-profile.pgodata -target %itanium_abi_triple | FileCheck -check-prefix=PGOUSE-EXC %s
// PGOGEN: @[[THC:__llvm_pgo_ctr[0-9]*]] = private global [11 x i64] zeroinitializer // PGOGEN: @[[THC:__llvm_pgo_ctr[0-9]*]] = private global [11 x i64] zeroinitializer
// PGOGEN-EXC: @[[THC:__llvm_pgo_ctr[0-9]*]] = private global [11 x i64] zeroinitializer // PGOGEN-EXC: @[[THC:__llvm_pgo_ctr[0-9]*]] = private global [11 x i64] zeroinitializer
// PGOGEN-LABEL: @_Z6throwsv() // PGOGEN-LABEL: @_Z6throwsv()
// PGOUSE-LABEL: @_Z6throwsv() // PGOUSE-LABEL: @_Z6throwsv()
// PGOGEN: store {{.*}} @[[THC]], i64 0, i64 0 // PGOGEN: store {{.*}} @[[THC]], i64 0, i64 0
void throws() { void throws() {
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

test/CodeGenCXX/instrument-functions.cpp

// RUN: %clang_cc1 -S -emit-llvm -cxx-abi itanium -o - %s -finstrument-functions | FileCheck %s // RUN: %clang_cc1 -S -emit-llvm -triple %itanium_abi_triple -o - %s -finstrument-functions | FileCheck %s
// CHECK: @_Z5test1i // CHECK: @_Z5test1i
int test1(int x) { int test1(int x) {
// CHECK: __cyg_profile_func_enter // CHECK: __cyg_profile_func_enter
// CHECK: __cyg_profile_func_exit // CHECK: __cyg_profile_func_exit
// CHECK: ret // CHECK: ret
return x; return x;
} }
Show All 21 Lines

test/CodeGenCXX/internal-linkage.cpp

// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -o - %s | FileCheck %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -o - %s | FileCheck %s
struct Global { Global(); }; struct Global { Global(); };
template<typename T> struct X { X() {} }; template<typename T> struct X { X() {} };
namespace { namespace {
struct Anon { Anon() {} }; struct Anon { Anon() {} };
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/CodeGenCXX/mangle-abi-examples.cpp

// RUN: %clang_cc1 %s -emit-llvm -cxx-abi itanium -o - | FileCheck %s // RUN: %clang_cc1 %s -emit-llvm -triple %itanium_abi_triple -o - | FileCheck %s
// CHECK: @_ZTVZ3foovEN1C1DE = // CHECK: @_ZTVZ3foovEN1C1DE =
// CHECK: @_ZTVZN1A3fooEiE1B = // CHECK: @_ZTVZN1A3fooEiE1B =
// CHECK: define {{.*}} @_ZZZ3foovEN1C3barEvEN1E3bazEv( // CHECK: define {{.*}} @_ZZZ3foovEN1C3barEvEN1E3bazEv(
// Itanium C++ ABI examples. // Itanium C++ ABI examples.
struct A { struct A {
void foo (int) { void foo (int) {
Show All 18 Lines

test/CodeGenCXX/mangle-address-space.cpp

// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -o - %s | FileCheck %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -o - %s | FileCheck %s
// CHECK-LABEL: define void @_Z2f0Pc // CHECK-LABEL: define void @_Z2f0Pc
void f0(char *p) { } void f0(char *p) { }
// CHECK-LABEL: define void @_Z2f0PU3AS1c // CHECK-LABEL: define void @_Z2f0PU3AS1c
void f0(char __attribute__((address_space(1))) *p) { } void f0(char __attribute__((address_space(1))) *p) { }
struct OpaqueType; struct OpaqueType;
typedef OpaqueType __attribute__((address_space(100))) * OpaqueTypePtr; typedef OpaqueType __attribute__((address_space(100))) * OpaqueTypePtr;
// CHECK-LABEL: define void @_Z2f0PU5AS10010OpaqueType // CHECK-LABEL: define void @_Z2f0PU5AS10010OpaqueType
void f0(OpaqueTypePtr) { } void f0(OpaqueTypePtr) { }

test/CodeGenCXX/mangle-local-class-names.cpp

// RUN: %clang_cc1 %s -emit-llvm -cxx-abi itanium -o - | FileCheck %s // RUN: %clang_cc1 %s -emit-llvm -triple %itanium_abi_triple -o - | FileCheck %s
// CHECK: @_ZZ4FUNCvEN4SSSSC1ERKf // CHECK: @_ZZ4FUNCvEN4SSSSC1ERKf
// CHECK: @_ZZ4FUNCvEN4SSSSC2E_0RKf // CHECK: @_ZZ4FUNCvEN4SSSSC2E_0RKf
// CHECK: @_ZZ4GORFfEN4SSSSC1ERKf // CHECK: @_ZZ4GORFfEN4SSSSC1ERKf
// CHECK: @_ZZ4GORFfEN4SSSSC2E_0RKf // CHECK: @_ZZ4GORFfEN4SSSSC2E_0RKf
void FUNC () void FUNC ()
{ {
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

test/CodeGenCXX/mangle-local-class-vtables.cpp

// RUN: %clang_cc1 %s -emit-llvm -cxx-abi itanium -o - | FileCheck %s // RUN: %clang_cc1 %s -emit-llvm -triple %itanium_abi_triple -o - | FileCheck %s
// CHECK: @_ZTVZN1J1KEvE1C = {{.*}} @_ZTIZN1J1KEvE1C {{.*}} @_ZZN1J1KEvENK1C1FEv // CHECK: @_ZTVZN1J1KEvE1C = {{.*}} @_ZTIZN1J1KEvE1C {{.*}} @_ZZN1J1KEvENK1C1FEv
// CHECK: @_ZTIZN1J1KEvE1C = {{.*}} @_ZTSZN1J1KEvE1C // CHECK: @_ZTIZN1J1KEvE1C = {{.*}} @_ZTSZN1J1KEvE1C
// CHECK: @_ZTVZ1GvE1C_1 = {{.*}} @_ZTIZ1GvE1C_1 {{.*}} @_ZZ1GvENK1C1FE_1v // CHECK: @_ZTVZ1GvE1C_1 = {{.*}} @_ZTIZ1GvE1C_1 {{.*}} @_ZZ1GvENK1C1FE_1v
// CHECK: @_ZTIZ1GvE1C_1 = {{.*}} @_ZTSZ1GvE1C_1 // CHECK: @_ZTIZ1GvE1C_1 = {{.*}} @_ZTSZ1GvE1C_1
// CHECK: @_ZTVZ1GvE1C_0 = {{.*}} @_ZTIZ1GvE1C_0 {{.*}} @_ZZ1GvENK1C1FE_0v // CHECK: @_ZTVZ1GvE1C_0 = {{.*}} @_ZTIZ1GvE1C_0 {{.*}} @_ZZ1GvENK1C1FE_0v
// CHECK: @_ZTIZ1GvE1C_0 = {{.*}} @_ZTSZ1GvE1C_0 // CHECK: @_ZTIZ1GvE1C_0 = {{.*}} @_ZTSZ1GvE1C_0
// CHECK: @_ZTVZ1GvE1C = {{.*}} @_ZTIZ1GvE1C {{.*}} @_ZZ1GvENK1C1FEv // CHECK: @_ZTVZ1GvE1C = {{.*}} @_ZTIZ1GvE1C {{.*}} @_ZZ1GvENK1C1FEv
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/CodeGenCXX/mangle-local-classes-nested.cpp

// RUN: %clang_cc1 %s -emit-llvm -cxx-abi itanium -o - | FileCheck %s // RUN: %clang_cc1 %s -emit-llvm -triple %itanium_abi_triple -o - | FileCheck %s
// CHECK: @_ZTVZZ1HvEN1S1IEvE1S = // CHECK: @_ZTVZZ1HvEN1S1IEvE1S =
// CHECK: define {{.*}} @_Z2L1v( // CHECK: define {{.*}} @_Z2L1v(
// CHECK: define {{.*}} @_ZZ2L1vEN1S2L2Ev( // CHECK: define {{.*}} @_ZZ2L1vEN1S2L2Ev(
// CHECK: define {{.*}} @_ZZ2L1vEN1S2L2E_0v( // CHECK: define {{.*}} @_ZZ2L1vEN1S2L2E_0v(
// CHECK: define {{.*}} @_ZZ1FvEN1S1T1S1T1GEv( // CHECK: define {{.*}} @_ZZ1FvEN1S1T1S1T1GEv(
// CHECK: define {{.*}} @_ZZZ2L1vEN1S2L2E_0vEN1S3L3cEv( // CHECK: define {{.*}} @_ZZZ2L1vEN1S2L2E_0vEN1S3L3cEv(
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/CodeGenCXX/mangle-ms-abi-examples.cpp

// RUN: %clang_cc1 -fms-extensions -fno-rtti -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 | FileCheck %s // RUN: %clang_cc1 -fms-extensions -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s
// CHECK: @"\01??_7D@C@?1??foo@@YAXXZ@6B@" = // CHECK: @"\01??_7D@C@?1??foo@@YAXXZ@6B@" =
// CHECK: @"\01??_7B@?1??foo@A@@QAEXH@Z@6B@" = // CHECK: @"\01??_7B@?1??foo@A@@QAEXH@Z@6B@" =
// CHECK: define {{.*}} @"\01?baz@E@?3??bar@C@?1??foo@@YAXXZ@QAEXXZ@QAEXXZ"( // CHECK: define {{.*}} @"\01?baz@E@?3??bar@C@?1??foo@@YAXXZ@QAEXXZ@QAEXXZ"(
// Microsoft Visual C++ ABI examples. // Microsoft Visual C++ ABI examples.
struct A { struct A {
void foo (int) { void foo (int) {
Show All 19 Lines

test/CodeGenCXX/mangle-ms-arg-qualifiers.cpp

// RUN: %clang_cc1 -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 | FileCheck %s // RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s
// RUN: %clang_cc1 -emit-llvm %s -o - -cxx-abi microsoft -triple=x86_64-pc-win32 | FileCheck -check-prefix=X64 %s // RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-pc-win32 | FileCheck -check-prefix=X64 %s
void foo(const unsigned int) {} void foo(const unsigned int) {}
// CHECK: "\01?foo@@YAXI@Z" // CHECK: "\01?foo@@YAXI@Z"
// X64: "\01?foo@@YAXI@Z" // X64: "\01?foo@@YAXI@Z"
void foo(const double) {} void foo(const double) {}
// CHECK: "\01?foo@@YAXN@Z" // CHECK: "\01?foo@@YAXN@Z"
// X64: "\01?foo@@YAXN@Z" // X64: "\01?foo@@YAXN@Z"
▲ Show 20 Lines • Show All 230 Lines • Show Last 20 Lines

test/CodeGenCXX/mangle-ms-back-references-pr13207.cpp

// RUN: %clang_cc1 -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 | FileCheck %s // RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s
template<class X, class Y, class Z> template<class X, class Y, class Z>
class A {}; class A {};
template<class X> template<class X>
class B {}; class B {};
template<class X> template<class X>
class C {}; class C {};
▲ Show 20 Lines • Show All 184 Lines • Show Last 20 Lines

test/CodeGenCXX/mangle-ms-back-references.cpp

// RUN: %clang_cc1 -fms-extensions -fblocks -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 | FileCheck %s // RUN: %clang_cc1 -fms-extensions -fblocks -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s
void f1(const char* a, const char* b) {} void f1(const char* a, const char* b) {}
// CHECK: "\01?f1@@YAXPBD0@Z" // CHECK: "\01?f1@@YAXPBD0@Z"
void f2(const char* a, char* b) {} void f2(const char* a, char* b) {}
// CHECK: "\01?f2@@YAXPBDPAD@Z" // CHECK: "\01?f2@@YAXPBDPAD@Z"
void f3(int a, const char* b, const char* c) {} void f3(int a, const char* b, const char* c) {}
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/CodeGenCXX/mangle-ms-cxx11.cpp

// RUN: %clang_cc1 -std=c++11 -fms-extensions -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 | FileCheck %s // RUN: %clang_cc1 -std=c++11 -fms-extensions -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s
// CHECK: "\01?LRef@@YAXAAH@Z" // CHECK: "\01?LRef@@YAXAAH@Z"
void LRef(int& a) { } void LRef(int& a) { }
// CHECK: "\01?RRef@@YAH$$QAH@Z" // CHECK: "\01?RRef@@YAH$$QAH@Z"
int RRef(int&& a) { return a; } int RRef(int&& a) { return a; }
// CHECK: "\01?Null@@YAX$$T@Z" // CHECK: "\01?Null@@YAX$$T@Z"
namespace std { typedef decltype(__nullptr) nullptr_t; } namespace std { typedef decltype(__nullptr) nullptr_t; }
void Null(std::nullptr_t) {} void Null(std::nullptr_t) {}

test/CodeGenCXX/mangle-ms-return-qualifiers.cpp

// RUN: %clang_cc1 -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 | FileCheck %s // RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s
void a1() {} void a1() {}
// CHECK: "\01?a1@@YAXXZ" // CHECK: "\01?a1@@YAXXZ"
int a2() { return 0; } int a2() { return 0; }
// CHECK: "\01?a2@@YAHXZ" // CHECK: "\01?a2@@YAHXZ"
const int a3() { return 0; } const int a3() { return 0; }
▲ Show 20 Lines • Show All 170 Lines • Show Last 20 Lines

test/CodeGenCXX/mangle-ms-template-callback.cpp

// RUN: %clang_cc1 -fblocks -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 | FileCheck %s // RUN: %clang_cc1 -fblocks -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s
template<typename Signature> template<typename Signature>
class C; class C;
template<typename Ret> template<typename Ret>
class C<Ret(void)> {}; class C<Ret(void)> {};
typedef C<void(void)> C0; typedef C<void(void)> C0;
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

test/CodeGenCXX/mangle-ms-templates.cpp

// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -cxx-abi microsoft -fms-extensions -fdelayed-template-parsing -triple=i386-pc-win32 | FileCheck %s // RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -fms-extensions -fdelayed-template-parsing -triple=i386-pc-win32 | FileCheck %s
// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -cxx-abi microsoft -fms-extensions -fdelayed-template-parsing -triple=x86_64-pc-win32 | FileCheck -check-prefix X64 %s // RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -fms-extensions -fdelayed-template-parsing -triple=x86_64-pc-win32 | FileCheck -check-prefix X64 %s
template<typename T> template<typename T>
class Class { class Class {
public: public:
Class() {} Class() {}
}; };
class Typename { }; class Typename { };
▲ Show 20 Lines • Show All 254 Lines • Show Last 20 Lines

test/CodeGenCXX/mangle-ms-vector-types.cpp

// RUN: %clang_cc1 -fms-extensions -ffreestanding -target-feature +avx -emit-llvm %s -o - -cxx-abi microsoft -triple=i686-pc-win32 | FileCheck %s // RUN: %clang_cc1 -fms-extensions -ffreestanding -target-feature +avx -emit-llvm %s -o - -triple=i686-pc-win32 | FileCheck %s
#include <xmmintrin.h> #include <xmmintrin.h>
#include <emmintrin.h> #include <emmintrin.h>
#include <immintrin.h> #include <immintrin.h>
void foo64(__m64) {} void foo64(__m64) {}
// CHECK: define void @"\01?foo64@@YAXT__m64@@@Z" // CHECK: define void @"\01?foo64@@YAXT__m64@@@Z"
Show All 24 Lines

test/CodeGenCXX/mangle-ms.cpp

// RUN: %clang_cc1 -fblocks -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 -std=c++11 | FileCheck %s // RUN: %clang_cc1 -fblocks -emit-llvm %s -o - -triple=i386-pc-win32 -std=c++11 | FileCheck %s
// RUN: %clang_cc1 -fblocks -emit-llvm %s -o - -cxx-abi microsoft -triple=x86_64-pc-win32 -std=c++11| FileCheck -check-prefix X64 %s // RUN: %clang_cc1 -fblocks -emit-llvm %s -o - -triple=x86_64-pc-win32 -std=c++11| FileCheck -check-prefix X64 %s
int a; int a;
// CHECK-DAG: @"\01?a@@3HA" // CHECK-DAG: @"\01?a@@3HA"
namespace N { namespace N {
int b; int b;
// CHECK-DAG: @"\01?b@N@@3HA" // CHECK-DAG: @"\01?b@N@@3HA"
▲ Show 20 Lines • Show All 437 Lines • Show Last 20 Lines

test/CodeGenCXX/mangle-nullptr-arg.cpp

// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
template<int *ip> struct IP {}; template<int *ip> struct IP {};
// CHECK-LABEL: define void @_Z5test12IPILPi0EE // CHECK-LABEL: define void @_Z5test12IPILPi0EE
void test1(IP<nullptr>) {} void test1(IP<nullptr>) {}
struct X{ }; struct X{ };
template<int X::*pm> struct PM {}; template<int X::*pm> struct PM {};
// CHECK-LABEL: define void @_Z5test22PMILM1Xi0EE // CHECK-LABEL: define void @_Z5test22PMILM1Xi0EE
void test2(PM<nullptr>) { } void test2(PM<nullptr>) { }
// CHECK-LABEL: define void @_Z5test316DependentTypePtrIPiLS0_0EE // CHECK-LABEL: define void @_Z5test316DependentTypePtrIPiLS0_0EE
template<typename T, T x> struct DependentTypePtr {}; template<typename T, T x> struct DependentTypePtr {};
void test3(DependentTypePtr<int*,nullptr>) { } void test3(DependentTypePtr<int*,nullptr>) { }

test/CodeGenCXX/mangle-std-externc.cpp

// RUN: %clang_cc1 %s -DNS=std -emit-llvm -cxx-abi itanium -o - | FileCheck %s --check-prefix=CHECK-STD // RUN: %clang_cc1 %s -DNS=std -emit-llvm -triple %itanium_abi_triple -o - | FileCheck %s --check-prefix=CHECK-STD
// RUN: %clang_cc1 %s -DNS=n -emit-llvm -cxx-abi itanium -o - | FileCheck %s --check-prefix=CHECK-N // RUN: %clang_cc1 %s -DNS=n -emit-llvm -triple %itanium_abi_triple -o - | FileCheck %s --check-prefix=CHECK-N
// _ZNSt1DISt1CE1iE = std::D<std::C>::i // _ZNSt1DISt1CE1iE = std::D<std::C>::i
// CHECK-STD: @_ZNSt1DISt1CE1iE = // CHECK-STD: @_ZNSt1DISt1CE1iE =
// _ZN1n1DINS_1CEE1iE == n::D<n::C>::i // _ZN1n1DINS_1CEE1iE == n::D<n::C>::i
// CHECK-N: @_ZN1n1DINS_1CEE1iE = // CHECK-N: @_ZN1n1DINS_1CEE1iE =
namespace NS { namespace NS {
Show All 17 Lines

test/CodeGenCXX/mangle-template.cpp

// RUN: %clang_cc1 -verify -Wno-return-type -Wno-main -std=c++11 -emit-llvm -cxx-abi itanium -o - %s | FileCheck %s // RUN: %clang_cc1 -verify -Wno-return-type -Wno-main -std=c++11 -emit-llvm -triple %itanium_abi_triple -o - %s | FileCheck %s
// expected-no-diagnostics // expected-no-diagnostics
namespace test1 { namespace test1 {
int x; int x;
template <int& D> class T { }; template <int& D> class T { };
// CHECK: void @_ZN5test12f0ENS_1TILZNS_1xEEEE( // CHECK: void @_ZN5test12f0ENS_1TILZNS_1xEEEE(
void f0(T<x> a0) {} void f0(T<x> a0) {}
} }
▲ Show 20 Lines • Show All 199 Lines • Show Last 20 Lines

test/CodeGenCXX/mangle-windows.cpp

// RUN: %clang_cc1 -emit-llvm %s -o - -cxx-abi microsoft \ // RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 | \
// RUN: -triple=i386-pc-win32 | FileCheck --check-prefix=WIN %s // RUN: FileCheck --check-prefix=WIN %s
// //
// RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-mingw32 | \ // RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-mingw32 | \
// RUN: FileCheck --check-prefix=ITANIUM %s // RUN: FileCheck --check-prefix=ITANIUM %s
void __stdcall f1(void) {} void __stdcall f1(void) {}
// WIN: define x86_stdcallcc void @"\01?f1@@YGXXZ" // WIN: define x86_stdcallcc void @"\01?f1@@YGXXZ"
// ITANIUM: define x86_stdcallcc void @"\01__Z2f1v@0" // ITANIUM: define x86_stdcallcc void @"\01__Z2f1v@0"
Show All 32 Lines

test/CodeGenCXX/member-alignment.cpp

// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium %s -o - | FileCheck %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple %s -o - | FileCheck %s
// rdar://7268289 // rdar://7268289
class t { class t {
public: public:
virtual void foo(void); virtual void foo(void);
void bar(void); void bar(void);
}; };
Show All 10 Lines

test/CodeGenCXX/microsoft-abi-alignment-fail.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm -cxx-abi microsoft -triple=i686-pc-win32 -o - %s 2>/dev/null | FileCheck %s // RUN: %clang_cc1 -fno-rtti -emit-llvm -triple=i686-pc-win32 -o - %s 2>/dev/null | FileCheck %s
// RUN: %clang_cc1 -fno-rtti -emit-llvm -cxx-abi microsoft -triple=x86_64-pc-win32 -o - %s 2>/dev/null | FileCheck %s -check-prefix CHECK-X64 // RUN: %clang_cc1 -fno-rtti -emit-llvm -triple=x86_64-pc-win32 -o - %s 2>/dev/null | FileCheck %s -check-prefix CHECK-X64
struct B { char a; }; struct B { char a; };
struct A : virtual B {} a; struct A : virtual B {} a;
// The <> indicate that the pointer is packed, which is required to support // The <> indicate that the pointer is packed, which is required to support
// microsoft layout in 32 bit mode, but not 64 bit mode. // microsoft layout in 32 bit mode, but not 64 bit mode.
// CHECK: %struct.A = type <{ i32*, %struct.B }> // CHECK: %struct.A = type <{ i32*, %struct.B }>
// CHECK-X64: %struct.A = type { i32*, %struct.B } // CHECK-X64: %struct.A = type { i32*, %struct.B }

test/CodeGenCXX/microsoft-abi-arg-order.cpp

// RUN: %clang_cc1 -mconstructor-aliases -std=c++11 -fexceptions -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 | FileCheck %s // RUN: %clang_cc1 -mconstructor-aliases -std=c++11 -fexceptions -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s
struct A { struct A {
A(int a); A(int a);
~A(); ~A();
int a; int a;
}; };
void foo(A a, A b, A c) { void foo(A a, A b, A c) {
Show All 32 Lines

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

// RUN: %clang_cc1 -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 | FileCheck %s // RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s
struct ClassWithoutDtor { struct ClassWithoutDtor {
char x; char x;
}; };
void check_array_no_cookies() { void check_array_no_cookies() {
// CHECK: define void @"\01?check_array_no_cookies@@YAXXZ"() [[NUW:#[0-9]+]] // CHECK: define void @"\01?check_array_no_cookies@@YAXXZ"() [[NUW:#[0-9]+]]
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/CodeGenCXX/microsoft-abi-constexpr-vs-inheritance.cpp

// RUN: %clang_cc1 -std=c++11 -fno-rtti -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 | FileCheck %s // RUN: %clang_cc1 -std=c++11 -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s
struct A { struct A {
constexpr A(int x) : x(x) {} constexpr A(int x) : x(x) {}
virtual void f(); virtual void f();
int x; int x;
}; };
A a(42); A a(42);
Show All 14 Lines

test/CodeGenCXX/microsoft-abi-default-cc.cpp

// RUN: %clang_cc1 -triple i386-pc-linux -emit-llvm %s -o - | FileCheck -check-prefix GCABI %s // RUN: %clang_cc1 -triple i386-pc-linux -emit-llvm %s -o - | FileCheck -check-prefix GCABI %s
// RUN: %clang_cc1 -emit-llvm %s -o - -DMS_ABI -cxx-abi microsoft -triple=i386-pc-win32 | FileCheck -check-prefix MSABI %s // RUN: %clang_cc1 -emit-llvm %s -o - -DMS_ABI -triple=i386-pc-win32 | FileCheck -check-prefix MSABI %s
#ifdef MS_ABI #ifdef MS_ABI
# define METHOD_CC __thiscall # define METHOD_CC __thiscall
#else #else
# define METHOD_CC __attribute__ ((cdecl)) # define METHOD_CC __attribute__ ((cdecl))
#endif #endif
// Test that it's OK to have multiple function declarations with the default CC // Test that it's OK to have multiple function declarations with the default CC
Show All 37 Lines

test/CodeGenCXX/microsoft-abi-exceptions.cpp

// RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 -mconstructor-aliases -cxx-abi microsoft -fexceptions -fno-rtti | FileCheck -check-prefix WIN32 %s // RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 -mconstructor-aliases -fexceptions -fno-rtti | FileCheck -check-prefix WIN32 %s
struct A { struct A {
A(); A();
~A(); ~A();
int a; int a;
}; };
A getA(); A getA();
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

test/CodeGenCXX/microsoft-abi-member-pointers.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 | FileCheck %s // RUN: %clang_cc1 -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s
// FIXME: Test x86_64 member pointers when codegen no longer asserts on records // FIXME: Test x86_64 member pointers when codegen no longer asserts on records
// with virtual bases. // with virtual bases.
struct B1 { struct B1 {
void foo(); void foo();
int b; int b;
}; };
struct B2 { struct B2 {
▲ Show 20 Lines • Show All 550 Lines • Show Last 20 Lines

test/CodeGenCXX/microsoft-abi-methods.cpp

// RUN: %clang_cc1 -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 | FileCheck %s // RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s
class C { class C {
public: public:
void simple_method() {} void simple_method() {}
void __cdecl cdecl_method() {} void __cdecl cdecl_method() {}
void vararg_method(const char *fmt, ...) {} void vararg_method(const char *fmt, ...) {}
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

test/CodeGenCXX/microsoft-abi-multiple-nonvirtual-inheritance.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm %s -o - -mconstructor-aliases -cxx-abi microsoft -triple=i386-pc-win32 | FileCheck %s // RUN: %clang_cc1 -fno-rtti -emit-llvm %s -o - -mconstructor-aliases -triple=i386-pc-win32 | FileCheck %s
struct Left { struct Left {
virtual void left(); virtual void left();
}; };
struct Right { struct Right {
virtual void right(); virtual void right();
}; };
▲ Show 20 Lines • Show All 192 Lines • Show Last 20 Lines

test/CodeGenCXX/microsoft-abi-non-virtual-base-ordering.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm -cxx-abi microsoft -triple=i686-pc-win32 -o - %s 2>/dev/null | FileCheck %s // RUN: %clang_cc1 -fno-rtti -emit-llvm -triple=i686-pc-win32 -o - %s 2>/dev/null | FileCheck %s
// RUN: %clang_cc1 -fno-rtti -emit-llvm -cxx-abi microsoft -triple=x86_64-pc-win32 -o - %s 2>/dev/null | FileCheck %s // RUN: %clang_cc1 -fno-rtti -emit-llvm -triple=x86_64-pc-win32 -o - %s 2>/dev/null | FileCheck %s
struct C0 { int a; }; struct C0 { int a; };
struct C1 { int a; virtual void C1M() {} }; struct C1 { int a; virtual void C1M() {} };
struct C2 { int a; virtual void C2M() {} }; struct C2 { int a; virtual void C2M() {} };
struct C3 : C0, C1, C2 {} a; struct C3 : C0, C1, C2 {} a;
// Check to see that both C1 and C2 get laid out before C0 does. // Check to see that both C1 and C2 get laid out before C0 does.
// CHECK: %struct.C3 = type { %struct.C1, %struct.C2, %struct.C0 } // CHECK: %struct.C3 = type { %struct.C1, %struct.C2, %struct.C0 }

test/CodeGenCXX/microsoft-abi-sret-and-byval.cpp

// RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-linux | FileCheck -check-prefix LINUX %s // RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-linux | FileCheck -check-prefix LINUX %s
// RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 -mconstructor-aliases -cxx-abi microsoft -fno-rtti | FileCheck -check-prefix WIN32 %s // RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 -mconstructor-aliases -fno-rtti | FileCheck -check-prefix WIN32 %s
// RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-pc-win32 -mconstructor-aliases -cxx-abi microsoft -fno-rtti | FileCheck -check-prefix WIN64 %s // RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-pc-win32 -mconstructor-aliases -fno-rtti | FileCheck -check-prefix WIN64 %s
struct Empty {}; struct Empty {};
struct EmptyWithCtor { struct EmptyWithCtor {
EmptyWithCtor() {} EmptyWithCtor() {}
}; };
struct Small { struct Small {
▲ Show 20 Lines • Show All 218 Lines • Show Last 20 Lines

test/CodeGenCXX/microsoft-abi-static-initializers.cpp

// RUN: %clang_cc1 -emit-llvm %s -o - -mconstructor-aliases -cxx-abi microsoft -triple=i386-pc-win32 | FileCheck %s // RUN: %clang_cc1 -emit-llvm %s -o - -mconstructor-aliases -triple=i386-pc-win32 | FileCheck %s
// CHECK: @llvm.global_ctors = appending global [2 x { i32, void ()* }] // CHECK: @llvm.global_ctors = appending global [2 x { i32, void ()* }]
// CHECK: [{ i32, void ()* } { i32 65535, void ()* @"\01??__Efoo@?$B@H@@YAXXZ" }, // CHECK: [{ i32, void ()* } { i32 65535, void ()* @"\01??__Efoo@?$B@H@@YAXXZ" },
// CHECK: { i32, void ()* } { i32 65535, void ()* @_GLOBAL__I_a }] // CHECK: { i32, void ()* } { i32 65535, void ()* @_GLOBAL__I_a }]
struct S { struct S {
S(); S();
~S(); ~S();
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

test/CodeGenCXX/microsoft-abi-structors-alias.cpp

// RUN: %clang_cc1 -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 -fno-rtti -mconstructor-aliases | FileCheck %s // RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 -fno-rtti -mconstructor-aliases | FileCheck %s
namespace test1 { namespace test1 {
template <typename T> class A { template <typename T> class A {
~A() {} ~A() {}
}; };
template class A<char>; template class A<char>;
// CHECK: define weak_odr x86_thiscallcc void @"\01??1?$A@D@test1@@AAE@XZ" // CHECK: define weak_odr x86_thiscallcc void @"\01??1?$A@D@test1@@AAE@XZ"
} }

test/CodeGenCXX/microsoft-abi-structors.cpp

// RUN: %clang_cc1 -emit-llvm %s -o - -mconstructor-aliases -cxx-abi microsoft -triple=i386-pc-win32 -fno-rtti > %t // RUN: %clang_cc1 -emit-llvm %s -o - -mconstructor-aliases -triple=i386-pc-win32 -fno-rtti > %t
// RUN: FileCheck %s < %t // RUN: FileCheck %s < %t
// vftables are emitted very late, so do another pass to try to keep the checks // vftables are emitted very late, so do another pass to try to keep the checks
// in source order. // in source order.
// RUN: FileCheck --check-prefix DTORS %s < %t // RUN: FileCheck --check-prefix DTORS %s < %t
// //
// RUN: %clang_cc1 -emit-llvm %s -o - -mconstructor-aliases -cxx-abi microsoft -triple=x86_64-pc-win32 -fno-rtti | FileCheck --check-prefix DTORS-X64 %s // RUN: %clang_cc1 -emit-llvm %s -o - -mconstructor-aliases -triple=x86_64-pc-win32 -fno-rtti | FileCheck --check-prefix DTORS-X64 %s
namespace basic { namespace basic {
class A { class A {
public: public:
A() { } A() { }
~A(); ~A();
}; };
▲ Show 20 Lines • Show All 332 Lines • Show Last 20 Lines

test/CodeGenCXX/microsoft-abi-thunks.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 >%t 2>&1 // RUN: %clang_cc1 -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 >%t 2>&1
// RUN: FileCheck --check-prefix=MANGLING %s < %t // RUN: FileCheck --check-prefix=MANGLING %s < %t
// RUN: FileCheck --check-prefix=XMANGLING %s < %t // RUN: FileCheck --check-prefix=XMANGLING %s < %t
// RUN: FileCheck --check-prefix=CODEGEN %s < %t // RUN: FileCheck --check-prefix=CODEGEN %s < %t
// RUN: %clang_cc1 -fno-rtti -emit-llvm %s -o - -cxx-abi microsoft -triple=x86_64-pc-win32 2>&1 | FileCheck --check-prefix=MANGLING-X64 %s // RUN: %clang_cc1 -fno-rtti -emit-llvm %s -o - -triple=x86_64-pc-win32 2>&1 | FileCheck --check-prefix=MANGLING-X64 %s
void foo(void *); void foo(void *);
struct A { struct A {
virtual ~A(); virtual ~A();
virtual void public_f(); virtual void public_f();
// Make sure we don't emit unneeded thunks: // Make sure we don't emit unneeded thunks:
// XMANGLING-NOT: @"\01?public_f@A@@QAEXXZ" // XMANGLING-NOT: @"\01?public_f@A@@QAEXXZ"
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

test/CodeGenCXX/microsoft-abi-vbtables.cpp

// RUN: %clang_cc1 %s -fno-rtti -cxx-abi microsoft -triple=i386-pc-win32 -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -fno-rtti -triple=i386-pc-win32 -emit-llvm -o - | FileCheck %s
// See microsoft-abi-structors.cpp for constructor codegen tests. // See microsoft-abi-structors.cpp for constructor codegen tests.
namespace Test1 { namespace Test1 {
// Classic diamond, fully virtual. // Classic diamond, fully virtual.
struct A { int a; }; struct A { int a; };
struct B : virtual A { int b; }; struct B : virtual A { int b; };
struct C : virtual A { int c; }; struct C : virtual A { int c; };
▲ Show 20 Lines • Show All 511 Lines • Show Last 20 Lines

test/CodeGenCXX/microsoft-abi-virtual-inheritance-vtordisps.cpp

// RUN: %clang_cc1 %s -fno-rtti -cxx-abi microsoft -triple=i386-pc-win32 -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -fno-rtti -triple=i386-pc-win32 -emit-llvm -o - | FileCheck %s
// For now, just make sure x86_64 doesn't crash. // For now, just make sure x86_64 doesn't crash.
// RUN: %clang_cc1 %s -fno-rtti -cxx-abi microsoft -triple=x86_64-pc-win32 -emit-llvm -o %t // RUN: %clang_cc1 %s -fno-rtti -triple=x86_64-pc-win32 -emit-llvm -o %t
struct A { struct A {
virtual void f(); virtual void f();
}; };
struct B { struct B {
virtual void f(); virtual void f();
}; };
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

test/CodeGenCXX/microsoft-abi-virtual-inheritance.cpp

// RUN: %clang_cc1 %s -fno-rtti -cxx-abi microsoft -triple=i386-pc-win32 -emit-llvm -o %t // RUN: %clang_cc1 %s -fno-rtti -triple=i386-pc-win32 -emit-llvm -o %t
// RUN: FileCheck %s < %t // RUN: FileCheck %s < %t
// RUN: FileCheck --check-prefix=CHECK2 %s < %t // RUN: FileCheck --check-prefix=CHECK2 %s < %t
// For now, just make sure x86_64 doesn't crash. // For now, just make sure x86_64 doesn't crash.
// RUN: %clang_cc1 %s -fno-rtti -cxx-abi microsoft -triple=x86_64-pc-win32 -emit-llvm -o %t // RUN: %clang_cc1 %s -fno-rtti -triple=x86_64-pc-win32 -emit-llvm -o %t
struct VBase { struct VBase {
virtual ~VBase(); virtual ~VBase();
virtual void foo(); virtual void foo();
virtual void bar(); virtual void bar();
int field; int field;
}; };
▲ Show 20 Lines • Show All 300 Lines • Show Last 20 Lines

test/CodeGenCXX/microsoft-abi-virtual-member-pointers.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm -cxx-abi microsoft -triple=i386-pc-win32 %s -o - | FileCheck %s --check-prefix=CHECK32 // RUN: %clang_cc1 -fno-rtti -emit-llvm -triple=i386-pc-win32 %s -o - | FileCheck %s --check-prefix=CHECK32
// RUN: %clang_cc1 -fno-rtti -emit-llvm -cxx-abi microsoft -triple=x86_64-pc-win32 %s -o - | FileCheck %s --check-prefix=CHECK64 // RUN: %clang_cc1 -fno-rtti -emit-llvm -triple=x86_64-pc-win32 %s -o - | FileCheck %s --check-prefix=CHECK64
struct S { struct S {
int x, y, z; int x, y, z;
}; };
struct C { struct C {
virtual void foo(); virtual void foo();
virtual int bar(int, double); virtual int bar(int, double);
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

test/CodeGenCXX/microsoft-abi-vtables-multiple-nonvirtual-inheritance.cpp

// RUN: %clang_cc1 %s -fno-rtti -cxx-abi microsoft -triple=i386-pc-win32 -emit-llvm -o %t.ll -fdump-vtable-layouts >%t // RUN: %clang_cc1 %s -fno-rtti -triple=i386-pc-win32 -emit-llvm -o %t.ll -fdump-vtable-layouts >%t
// RUN: FileCheck --check-prefix=NO-THUNKS-Test1 %s < %t // RUN: FileCheck --check-prefix=NO-THUNKS-Test1 %s < %t
// RUN: FileCheck --check-prefix=NO-THUNKS-Test2 %s < %t // RUN: FileCheck --check-prefix=NO-THUNKS-Test2 %s < %t
// RUN: FileCheck --check-prefix=NO-THUNKS-Test3 %s < %t // RUN: FileCheck --check-prefix=NO-THUNKS-Test3 %s < %t
// RUN: FileCheck --check-prefix=NO-THUNKS-Test4 %s < %t // RUN: FileCheck --check-prefix=NO-THUNKS-Test4 %s < %t
// RUN: FileCheck --check-prefix=NO-THUNKS-Test5 %s < %t // RUN: FileCheck --check-prefix=NO-THUNKS-Test5 %s < %t
// RUN: FileCheck --check-prefix=NO-THUNKS-Test6 %s < %t // RUN: FileCheck --check-prefix=NO-THUNKS-Test6 %s < %t
// RUN: FileCheck --check-prefix=NO-THUNKS-Test7 %s < %t // RUN: FileCheck --check-prefix=NO-THUNKS-Test7 %s < %t
▲ Show 20 Lines • Show All 570 Lines • Show Last 20 Lines

test/CodeGenCXX/microsoft-abi-vtables-return-thunks.cpp

// RUN: %clang_cc1 -fno-rtti %s -emit-llvm -o %t -cxx-abi microsoft -triple=i386-pc-win32 -fdump-vtable-layouts 2>&1 | FileCheck --check-prefix=VFTABLES %s // RUN: %clang_cc1 -fno-rtti %s -emit-llvm -o %t -triple=i386-pc-win32 -fdump-vtable-layouts 2>&1 | FileCheck --check-prefix=VFTABLES %s
// RUN: FileCheck --check-prefix=GLOBALS %s < %t // RUN: FileCheck --check-prefix=GLOBALS %s < %t
// RUN: FileCheck --check-prefix=CODEGEN %s < %t // RUN: FileCheck --check-prefix=CODEGEN %s < %t
namespace test1 { namespace test1 {
// Some covariant types. // Some covariant types.
struct A { int a; }; struct A { int a; };
struct B { int b; }; struct B { int b; };
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

test/CodeGenCXX/microsoft-abi-vtables-single-inheritance.cpp

// RUN: %clang_cc1 %s -fno-rtti -cxx-abi microsoft -triple=i386-pc-win32 -emit-llvm -fdump-vtable-layouts -o %t.ll > %t // RUN: %clang_cc1 %s -fno-rtti -triple=i386-pc-win32 -emit-llvm -fdump-vtable-layouts -o %t.ll > %t
// RUN: FileCheck --check-prefix=EMITS-VFTABLE %s < %t.ll // RUN: FileCheck --check-prefix=EMITS-VFTABLE %s < %t.ll
// RUN: FileCheck --check-prefix=NO-VFTABLE %s < %t.ll // RUN: FileCheck --check-prefix=NO-VFTABLE %s < %t.ll
// RUN: FileCheck --check-prefix=CHECK-A %s < %t // RUN: FileCheck --check-prefix=CHECK-A %s < %t
// RUN: FileCheck --check-prefix=CHECK-B %s < %t // RUN: FileCheck --check-prefix=CHECK-B %s < %t
// RUN: FileCheck --check-prefix=CHECK-C %s < %t // RUN: FileCheck --check-prefix=CHECK-C %s < %t
// RUN: FileCheck --check-prefix=CHECK-D %s < %t // RUN: FileCheck --check-prefix=CHECK-D %s < %t
// RUN: FileCheck --check-prefix=CHECK-E %s < %t // RUN: FileCheck --check-prefix=CHECK-E %s < %t
// RUN: FileCheck --check-prefix=CHECK-F %s < %t // RUN: FileCheck --check-prefix=CHECK-F %s < %t
▲ Show 20 Lines • Show All 253 Lines • Show Last 20 Lines

test/CodeGenCXX/microsoft-abi-vtables-virtual-inheritance-vtordisps.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm -fdump-vtable-layouts %s -o %t.ll -cxx-abi microsoft -triple=i386-pc-win32 >%t // RUN: %clang_cc1 -fno-rtti -emit-llvm -fdump-vtable-layouts %s -o %t.ll -triple=i386-pc-win32 > %t
// RUN: FileCheck --check-prefix=VTABLE-SIMPLE-A %s < %t // RUN: FileCheck --check-prefix=VTABLE-SIMPLE-A %s < %t
// RUN: FileCheck --check-prefix=VTABLE-SIMPLE-B %s < %t // RUN: FileCheck --check-prefix=VTABLE-SIMPLE-B %s < %t
// RUN: FileCheck --check-prefix=VTABLE-SIMPLE-C %s < %t // RUN: FileCheck --check-prefix=VTABLE-SIMPLE-C %s < %t
// RUN: FileCheck --check-prefix=VTABLE-EXTENDED-A %s < %t // RUN: FileCheck --check-prefix=VTABLE-EXTENDED-A %s < %t
// RUN: FileCheck --check-prefix=VTABLE-EXTENDED-B %s < %t // RUN: FileCheck --check-prefix=VTABLE-EXTENDED-B %s < %t
// RUN: FileCheck --check-prefix=VTABLE-EXTENDED-C %s < %t // RUN: FileCheck --check-prefix=VTABLE-EXTENDED-C %s < %t
// RUN: FileCheck --check-prefix=VTABLE-EXTENDED-E %s < %t // RUN: FileCheck --check-prefix=VTABLE-EXTENDED-E %s < %t
// RUN: FileCheck --check-prefix=VTABLE-EXTENDED-F %s < %t // RUN: FileCheck --check-prefix=VTABLE-EXTENDED-F %s < %t
// RUN: FileCheck --check-prefix=VTABLE-EXTENDED-G %s < %t // RUN: FileCheck --check-prefix=VTABLE-EXTENDED-G %s < %t
// RUN: FileCheck --check-prefix=VTABLE-EXTENDED-H %s < %t // RUN: FileCheck --check-prefix=VTABLE-EXTENDED-H %s < %t
// RUN: FileCheck --check-prefix=VTABLE-PR17738-A %s < %t // RUN: FileCheck --check-prefix=VTABLE-PR17738-A %s < %t
// RUN: FileCheck --check-prefix=MANGLING %s < %t.ll // RUN: FileCheck --check-prefix=MANGLING %s < %t.ll
// For now, just make sure x86_64 doesn't crash. // For now, just make sure x86_64 doesn't crash.
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -fdump-vtable-layouts %s -cxx-abi microsoft -triple=x86_64-pc-win32 >/dev/null // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -fdump-vtable-layouts %s -triple=x86_64-pc-win32 > /dev/null
struct V1 { struct V1 {
virtual void f(); virtual void f();
virtual ~V1(); virtual ~V1();
}; };
struct V2 { struct V2 {
virtual void f(); virtual void f();
▲ Show 20 Lines • Show All 300 Lines • Show Last 20 Lines

test/CodeGenCXX/microsoft-abi-vtables-virtual-inheritance.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm -o %t.ll -fdump-vtable-layouts %s -cxx-abi microsoft -triple=i386-pc-win32 >%t // RUN: %clang_cc1 -fno-rtti -emit-llvm -o %t.ll -fdump-vtable-layouts %s -triple=i386-pc-win32 >%t
// RUN: FileCheck --check-prefix=VTABLE-C %s < %t // RUN: FileCheck --check-prefix=VTABLE-C %s < %t
// RUN: FileCheck --check-prefix=VTABLE-D %s < %t // RUN: FileCheck --check-prefix=VTABLE-D %s < %t
// RUN: FileCheck --check-prefix=TEST1 %s < %t // RUN: FileCheck --check-prefix=TEST1 %s < %t
// RUN: FileCheck --check-prefix=TEST2 %s < %t // RUN: FileCheck --check-prefix=TEST2 %s < %t
// RUN: FileCheck --check-prefix=TEST3 %s < %t // RUN: FileCheck --check-prefix=TEST3 %s < %t
// RUN: FileCheck --check-prefix=TEST4 %s < %t // RUN: FileCheck --check-prefix=TEST4 %s < %t
// RUN: FileCheck --check-prefix=TEST5 %s < %t // RUN: FileCheck --check-prefix=TEST5 %s < %t
▲ Show 20 Lines • Show All 586 Lines • Show Last 20 Lines

test/CodeGenCXX/microsoft-new.cpp

// RUN: %clang_cc1 -triple i686-pc-win32 -cxx-abi itanium -fms-compatibility %s -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 -triple i686-pc-win32 -fms-compatibility %s -emit-llvm -o - | FileCheck %s
#include <stddef.h> #include <stddef.h>
struct arbitrary_t {} arbitrary; struct arbitrary_t {} arbitrary;
void *operator new(size_t size, arbitrary_t); void *operator new(size_t size, arbitrary_t);
struct arbitrary2_t {} arbitrary2; struct arbitrary2_t {} arbitrary2;
void *operator new[](size_t size, arbitrary2_t); void *operator new[](size_t size, arbitrary2_t);
namespace PR13164 { namespace PR13164 {
void f() { void f() {
// MSVC will fall back on the non-array operator new. // MSVC will fall back on the non-array operator new.
void *a; void *a;
int *p = new(arbitrary) int[4]; int *p = new(arbitrary) int[4];
// CHECK: call i8* @_Znwj11arbitrary_t(i32 16, %struct.arbitrary_t* // CHECK: call i8* @"\01??2@YAPAXIUarbitrary_t@@@Z"(i32 16, %struct.arbitrary_t*
} }
struct S { struct S {
void *operator new[](size_t size, arbitrary_t); void *operator new[](size_t size, arbitrary_t);
}; };
void g() { void g() {
S *s = new(arbitrary) S[2]; S *s = new(arbitrary) S[2];
// CHECK: call i8* @_ZN7PR131641SnaEj11arbitrary_t(i32 2, %struct.arbitrary_t* // CHECK: call i8* @"\01??_US@PR13164@@SAPAXIUarbitrary_t@@@Z"(i32 2, %struct.arbitrary_t*
S *s1 = new(arbitrary) S; S *s1 = new(arbitrary) S;
// CHECK: call i8* @_Znwj11arbitrary_t(i32 1, %struct.arbitrary_t* // CHECK: call i8* @"\01??2@YAPAXIUarbitrary_t@@@Z"(i32 1, %struct.arbitrary_t*
} }
struct T { struct T {
void *operator new(size_t size, arbitrary2_t); void *operator new(size_t size, arbitrary2_t);
}; };
void h() { void h() {
// This should still call the global operator new[]. // This should still call the global operator new[].
T *t = new(arbitrary2) T[2]; T *t = new(arbitrary2) T[2];
// CHECK: call i8* @_Znaj12arbitrary2_t(i32 2, %struct.arbitrary2_t* // CHECK: call i8* @"\01??_U@YAPAXIUarbitrary2_t@@@Z"(i32 2, %struct.arbitrary2_t*
} }
} }

test/CodeGenCXX/microsoft-uuidof.cpp

// RUN: %clang_cc1 -emit-llvm %s -o - -DDEFINE_GUID -triple=i386-pc-win32 -fms-extensions -cxx-abi itanium | FileCheck %s --check-prefix=CHECK-DEFINE-GUID // RUN: %clang_cc1 -emit-llvm %s -o - -DDEFINE_GUID -triple=i386-pc-linux -fms-extensions | FileCheck %s --check-prefix=CHECK-DEFINE-GUID
// RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 -fms-extensions -cxx-abi itanium | FileCheck %s // RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-linux -fms-extensions | FileCheck %s
// RUN: %clang_cc1 -emit-llvm %s -o - -DDEFINE_GUID -DWRONG_GUID -triple=i386-pc-win32 -fms-extensions -cxx-abi itanium | FileCheck %s --check-prefix=CHECK-DEFINE-WRONG-GUID // RUN: %clang_cc1 -emit-llvm %s -o - -DDEFINE_GUID -DWRONG_GUID -triple=i386-pc-linux -fms-extensions | FileCheck %s --check-prefix=CHECK-DEFINE-WRONG-GUID
#ifdef DEFINE_GUID #ifdef DEFINE_GUID
struct _GUID { struct _GUID {
#ifdef WRONG_GUID #ifdef WRONG_GUID
unsigned int SomethingWentWrong; unsigned int SomethingWentWrong;
#else #else
unsigned long Data1; unsigned long Data1;
unsigned short Data2; unsigned short Data2;
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

test/CodeGenCXX/ms-integer-static-data-members.cpp

// RUN: %clang_cc1 -emit-llvm -cxx-abi microsoft -triple=i386-pc-win32 %s -o - | FileCheck %s // RUN: %clang_cc1 -emit-llvm -triple=i386-pc-win32 %s -o - | FileCheck %s
// RUN: %clang_cc1 -DINLINE_INIT -emit-llvm -cxx-abi microsoft -triple=i386-pc-win32 %s -o - | FileCheck %s --check-prefix=CHECK-INLINE // RUN: %clang_cc1 -DINLINE_INIT -emit-llvm -triple=i386-pc-win32 %s -o - | FileCheck %s --check-prefix=CHECK-INLINE
// RUN: %clang_cc1 -DREAL_DEFINITION -emit-llvm -cxx-abi microsoft -triple=i386-pc-win32 %s -o - | FileCheck %s --check-prefix=CHECK-OUTOFLINE // RUN: %clang_cc1 -DREAL_DEFINITION -emit-llvm -triple=i386-pc-win32 %s -o - | FileCheck %s --check-prefix=CHECK-OUTOFLINE
// RUN: %clang_cc1 -DINLINE_INIT -DREAL_DEFINITION -emit-llvm -cxx-abi microsoft -triple=i386-pc-win32 %s -o - | FileCheck %s --check-prefix=CHECK-INLINE // RUN: %clang_cc1 -DINLINE_INIT -DREAL_DEFINITION -emit-llvm -triple=i386-pc-win32 %s -o - | FileCheck %s --check-prefix=CHECK-INLINE
struct S { struct S {
// For MS ABI, we emit a linkonce_odr definition here, even though it's really just a declaration. // For MS ABI, we emit a linkonce_odr definition here, even though it's really just a declaration.
#ifdef INLINE_INIT #ifdef INLINE_INIT
static const int x = 5; static const int x = 5;
#else #else
static const int x; static const int x;
#endif #endif
Show All 23 Lines

test/CodeGenCXX/ms_wide_predefined_expr.cpp

// RUN: %clang_cc1 %s -fms-extensions -triple i686-pc-win32 -cxx-abi itanium -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -fms-extensions -triple i686-pc-win32 -emit-llvm -o - | FileCheck %s
// CHECK: @L__FUNCTION__._Z4funcv = private constant [5 x i16] [i16 102, i16 117, i16 110, i16 99, i16 0], align 2 // CHECK: @"L__FUNCTION__.?func@@YAXXZ" = private constant [5 x i16] [i16 102, i16 117, i16 110, i16 99, i16 0], align 2
void wprint(const wchar_t*); void wprint(const wchar_t*);
#define __STR2WSTR(str) L##str #define __STR2WSTR(str) L##str
#define _STR2WSTR(str) __STR2WSTR(str) #define _STR2WSTR(str) __STR2WSTR(str)
#define STR2WSTR(str) _STR2WSTR(str) #define STR2WSTR(str) _STR2WSTR(str)
void func() { void func() {
Show All 9 Lines

test/CodeGenCXX/noinline-template.cpp

// RUN: %clang_cc1 %s -emit-llvm -cxx-abi itanium -o - | FileCheck %s // RUN: %clang_cc1 %s -emit-llvm -triple %itanium_abi_triple -o - | FileCheck %s
// This was a problem in Sema, but only shows up as noinline missing // This was a problem in Sema, but only shows up as noinline missing
// in CodeGen. // in CodeGen.
// CHECK: define linkonce_odr {{.*}}void @_ZN6VectorIiE13growStorageByEv(%struct.Vector* %this) [[NI:#[0-9]+]] // CHECK: define linkonce_odr {{.*}}void @_ZN6VectorIiE13growStorageByEv(%struct.Vector* %this) [[NI:#[0-9]+]]
template <class Ty> struct Vector { template <class Ty> struct Vector {
void growStorageBy(); void growStorageBy();
Show All 9 Lines

test/CodeGenCXX/pr11797.cpp

// RUN: %clang_cc1 %s -fvisibility hidden -cxx-abi itanium -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -fvisibility hidden -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
namespace std __attribute__ ((__visibility__ ("default"))) {} namespace std __attribute__ ((__visibility__ ("default"))) {}
#pragma GCC visibility push(default) #pragma GCC visibility push(default)
void foo() { void foo() {
} }
#pragma GCC visibility pop #pragma GCC visibility pop
// CHECK-LABEL: define void @_Z3foov() // CHECK-LABEL: define void @_Z3foov()

test/CodeGenCXX/pr12104.cpp

// RUN: %clang_cc1 -include %S/pr12104.h %s -cxx-abi itanium -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 -include %S/pr12104.h %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 -x c++ -cxx-abi itanium -emit-pch -o %t %S/pr12104.h // RUN: %clang_cc1 -x c++ -triple %itanium_abi_triple -emit-pch -o %t %S/pr12104.h
// RUN: %clang_cc1 -include-pch %t %s -cxx-abi itanium -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 -include-pch %t %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
template struct Patch<1>; template struct Patch<1>;
// CHECK: _ZN5PatchILi1EE11no_neighborE // CHECK: _ZN5PatchILi1EE11no_neighborE

test/CodeGenCXX/pr9965.cpp

// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
struct A { A(); }; struct A { A(); };
template<typename T> template<typename T>
struct X : A // default constructor is not trivial struct X : A // default constructor is not trivial
{ {
X() = default; X() = default;
~X() {} // not a literal type ~X() {} // not a literal type
}; };
X<int> x; X<int> x;
// CHECK-LABEL: define internal void @__cxx_global_var_init() // CHECK-LABEL: define internal void @__cxx_global_var_init()
// CHECK: call {{.*}} @_ZN1XIiEC1Ev // CHECK: call {{.*}} @_ZN1XIiEC1Ev
// CHECK: define linkonce_odr {{.*}} @_ZN1XIiEC1Ev // CHECK: define linkonce_odr {{.*}} @_ZN1XIiEC1Ev
// CHECK: define linkonce_odr {{.*}} @_ZN1XIiEC2Ev // CHECK: define linkonce_odr {{.*}} @_ZN1XIiEC2Ev

test/CodeGenCXX/pragma-weak.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck %s
#pragma weak zex #pragma weak zex
int zex; int zex;
// GCC produces a weak symbol for this because it matches mangled names. // GCC produces a weak symbol for this because it matches mangled names.
// Different c++ ABIs may or may not mangle this, so we produce a strong // Different c++ ABIs may or may not mangle this, so we produce a strong
// symbol. // symbol.
// CHECK: @zex = global i32 // CHECK: @zex = global i32
Show All 22 Lines

test/CodeGenCXX/predefined-expr.cpp

// RUN: %clang_cc1 -std=c++11 %s -cxx-abi itanium -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 -std=c++11 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
// CHECK: private unnamed_addr constant [15 x i8] c"externFunction\00" // CHECK: private unnamed_addr constant [15 x i8] c"externFunction\00"
// CHECK: private unnamed_addr constant [26 x i8] c"void NS::externFunction()\00" // CHECK: private unnamed_addr constant [26 x i8] c"void NS::externFunction()\00"
// CHECK: private unnamed_addr constant [49 x i8] c"void functionTemplateExplicitSpecialization(int)\00" // CHECK: private unnamed_addr constant [49 x i8] c"void functionTemplateExplicitSpecialization(int)\00"
// CHECK: private unnamed_addr constant [95 x i8] c"void SpecializedClassTemplate<char>::memberFunctionTemplate(T, U) const [T = char, U = double]\00" // CHECK: private unnamed_addr constant [95 x i8] c"void SpecializedClassTemplate<char>::memberFunctionTemplate(T, U) const [T = char, U = double]\00"
// CHECK: private unnamed_addr constant [85 x i8] c"void SpecializedClassTemplate<int>::memberFunctionTemplate(int, U) const [U = float]\00" // CHECK: private unnamed_addr constant [85 x i8] c"void SpecializedClassTemplate<int>::memberFunctionTemplate(int, U) const [U = float]\00"
// CHECK: private unnamed_addr constant [57 x i8] c"void NonTypeTemplateParam<42>::size() const [Count = 42]\00" // CHECK: private unnamed_addr constant [57 x i8] c"void NonTypeTemplateParam<42>::size() const [Count = 42]\00"
▲ Show 20 Lines • Show All 530 Lines • Show Last 20 Lines

test/CodeGenCXX/reference-field.cpp

// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -o - %s -O2 | FileCheck %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -o - %s -O2 | FileCheck %s
// Make sure the call to b() doesn't get optimized out. // Make sure the call to b() doesn't get optimized out.
extern struct x {char& x,y;}y; extern struct x {char& x,y;}y;
int b(); int b();
int a() { if (!&y.x) b(); } int a() { if (!&y.x) b(); }
// CHECK: @_Z1bv // CHECK: @_Z1bv

test/CodeGenCXX/reference-init.cpp

// RUN: %clang_cc1 -emit-llvm-only -cxx-abi itanium -verify %s // RUN: %clang_cc1 -emit-llvm-only -triple %itanium_abi_triple -verify %s
// expected-no-diagnostics // expected-no-diagnostics
struct XPTParamDescriptor {}; struct XPTParamDescriptor {};
struct nsXPTParamInfo { struct nsXPTParamInfo {
nsXPTParamInfo(const XPTParamDescriptor& desc); nsXPTParamInfo(const XPTParamDescriptor& desc);
}; };
void a(XPTParamDescriptor *params) { void a(XPTParamDescriptor *params) {
const nsXPTParamInfo& paramInfo = params[0]; const nsXPTParamInfo& paramInfo = params[0];
Show All 16 Lines

test/CodeGenCXX/return.cpp

// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -o - %s | FileCheck %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -o - %s | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -O -o - %s | FileCheck %s --check-prefix=CHECK-OPT // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -O -o - %s | FileCheck %s --check-prefix=CHECK-OPT
// CHECK: @_Z9no_return // CHECK: @_Z9no_return
// CHECK-OPT: @_Z9no_return // CHECK-OPT: @_Z9no_return
int no_return() { int no_return() {
// CHECK: call void @llvm.trap // CHECK: call void @llvm.trap
// CHECK-NEXT: unreachable // CHECK-NEXT: unreachable
// CHECK-OPT-NOT: call void @llvm.trap // CHECK-OPT-NOT: call void @llvm.trap
// CHECK-OPT: unreachable // CHECK-OPT: unreachable
} }

test/CodeGenCXX/scoped-enums.cpp

// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
// PR9923 // PR9923
enum class Color { red, blue, green }; enum class Color { red, blue, green };
void f(Color); void f(Color);
void g() { void g() {
f(Color::red); f(Color::red);
} }
Show All 15 Lines

test/CodeGenCXX/specialized-static-data-mem-init.cpp

// RUN: %clang_cc1 %s -emit-llvm -cxx-abi itanium -o - | FileCheck %s // RUN: %clang_cc1 %s -emit-llvm -triple %itanium_abi_triple -o - | FileCheck %s
// rdar: // 8562966 // rdar: // 8562966
// pr8409 // pr8409
// CHECK: @_ZN1CIiE11needs_guardE = weak_odr global // CHECK: @_ZN1CIiE11needs_guardE = weak_odr global
// CHECK: @_ZGVN1CIiE11needs_guardE = weak_odr global // CHECK: @_ZGVN1CIiE11needs_guardE = weak_odr global
struct K struct K
{ {
Show All 20 Lines

test/CodeGenCXX/stmtexpr.cpp

// RUN: %clang_cc1 -Wno-unused-value -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -Wno-unused-value -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
// rdar: //8540501 // rdar: //8540501
extern "C" int printf(...); extern "C" int printf(...);
extern "C" void abort(); extern "C" void abort();
struct A struct A
{ {
int i; int i;
A (int j) : i(j) {printf("this = %p A(%d)\n", this, j);} A (int j) : i(j) {printf("this = %p A(%d)\n", this, j);}
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

test/CodeGenCXX/template-dependent-bind-temporary.cpp

// RUN: %clang_cc1 %s -emit-llvm -cxx-abi itanium -o - | FileCheck %s // RUN: %clang_cc1 %s -emit-llvm -triple %itanium_abi_triple -o - | FileCheck %s
// rdar: //8620524 // rdar: //8620524
// PR7851 // PR7851
struct string { struct string {
string (const string& ); string (const string& );
string (); string ();
~string(); ~string();
}; };
Show All 15 Lines

test/CodeGenCXX/template-inner-struct-visibility-hidden.cpp

// RUN: %clang_cc1 -fvisibility hidden -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -fvisibility hidden -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
// Verify that symbols are hidden. // Verify that symbols are hidden.
// CHECK: @_ZN1CIiE5Inner6Inner26StaticE = weak_odr hidden global // CHECK: @_ZN1CIiE5Inner6Inner26StaticE = weak_odr hidden global
// CHECK-LABEL: define weak_odr hidden {{.*}}void @_ZN1CIiE5Inner1fEv // CHECK-LABEL: define weak_odr hidden {{.*}}void @_ZN1CIiE5Inner1fEv
// CHECK-LABEL: define weak_odr hidden {{.*}}void @_ZN1CIiE5Inner6Inner21gEv // CHECK-LABEL: define weak_odr hidden {{.*}}void @_ZN1CIiE5Inner6Inner21gEv
template<typename T> template<typename T>
struct C { struct C {
Show All 15 Lines

test/CodeGenCXX/throw-expression-dtor.cpp

// RUN: %clang_cc1 %s -emit-llvm-only -verify -cxx-abi itanium -fcxx-exceptions -fexceptions // RUN: %clang_cc1 %s -emit-llvm-only -verify -triple %itanium_abi_triple -fcxx-exceptions -fexceptions
// expected-no-diagnostics // expected-no-diagnostics
// PR7281 // PR7281
class A { class A {
public: public:
~A(); ~A();
}; };
class B : public A { class B : public A {
void ice_throw(); void ice_throw();
}; };
void B::ice_throw() { void B::ice_throw() {
throw *this; throw *this;
} }

test/CodeGenCXX/thunk-use-after-free.cpp

// RUN: %clang_cc1 -emit-llvm-only -cxx-abi itanium -O1 %s // RUN: %clang_cc1 -emit-llvm-only -triple %itanium_abi_triple -O1 %s
// This used to crash under asan and valgrind. // This used to crash under asan and valgrind.
// PR12284 // PR12284
template < typename _Tp > struct new_allocator template < typename _Tp > struct new_allocator
{ {
typedef _Tp *pointer; typedef _Tp *pointer;
template < typename > struct rebind { template < typename > struct rebind {
typedef new_allocator other; typedef new_allocator other;
Show All 33 Lines

test/CodeGenCXX/trivial-constructor-init.cpp

// RUN: %clang_cc1 -emit-llvm %s -o - -std=c++11 -cxx-abi itanium | FileCheck %s // RUN: %clang_cc1 -emit-llvm %s -o - -std=c++11 -triple %itanium_abi_triple | FileCheck %s
extern "C" int printf(...); extern "C" int printf(...);
struct S { struct S {
S() { printf("S::S\n"); } S() { printf("S::S\n"); }
}; };
struct A { struct A {
Show All 25 Lines

test/CodeGenCXX/vararg-non-pod.cpp

// RUN: %clang_cc1 -Wno-error=non-pod-varargs -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -Wno-error=non-pod-varargs -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
struct X { struct X {
X(); X();
X(const X&); X(const X&);
~X(); ~X();
}; };
void vararg(...); void vararg(...);
// CHECK-LABEL: define void @_Z4test1X // CHECK-LABEL: define void @_Z4test1X
void test(X x) { void test(X x) {
// CHECK: call void @llvm.trap() // CHECK: call void @llvm.trap()
vararg(x); vararg(x);
// CHECK: ret void // CHECK: ret void
} }

test/CodeGenCXX/virt-dtor-gen.cpp

// RUN: %clang_cc1 -o - -cxx-abi itanium -emit-llvm %s | FileCheck %s // RUN: %clang_cc1 -o - -triple %itanium_abi_triple -emit-llvm %s | FileCheck %s
// PR5483 // PR5483
// Make sure we generate all three forms of the destructor when it is virtual. // Make sure we generate all three forms of the destructor when it is virtual.
class Foo { class Foo {
virtual ~Foo(); virtual ~Foo();
}; };
Foo::~Foo() {} Foo::~Foo() {}
// CHECK-LABEL: define {{.*}}void @_ZN3FooD0Ev(%class.Foo* %this) unnamed_addr // CHECK-LABEL: define {{.*}}void @_ZN3FooD0Ev(%class.Foo* %this) unnamed_addr

test/CodeGenCXX/virt-dtor-key.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck %s
// CHECK: @_ZTI3foo = unnamed_addr constant // CHECK: @_ZTI3foo = unnamed_addr constant
class foo { class foo {
foo(); foo();
virtual ~foo(); virtual ~foo();
}; };
foo::~foo() { foo::~foo() {
} }

test/CodeGenCXX/virt-template-vtable.cpp

// RUN: %clang_cc1 %s -cxx-abi itanium -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
template<class T> class A { template<class T> class A {
public: public:
A() {} A() {}
virtual void a() {} virtual void a() {}
}; };
class B : A<int> { class B : A<int> {
B(); B();
Show All 23 Lines

test/CodeGenCXX/virtual-base-cast.cpp

// RUN: %clang_cc1 -emit-llvm %s -o - -triple i686-pc-linux-gnu | FileCheck %s // RUN: %clang_cc1 -emit-llvm %s -o - -triple i686-pc-linux-gnu | FileCheck %s
// RUN: %clang_cc1 -cxx-abi microsoft -emit-llvm %s -o - -triple i686-pc-win32 | FileCheck -check-prefix MSVC %s // RUN: %clang_cc1 -emit-llvm %s -o - -triple i686-pc-win32 | FileCheck -check-prefix MSVC %s
struct A { int a; virtual int aa(); }; struct A { int a; virtual int aa(); };
struct B { int b; virtual int bb(); }; struct B { int b; virtual int bb(); };
struct C : virtual A, virtual B { int c; virtual int aa(); virtual int bb(); }; struct C : virtual A, virtual B { int c; virtual int aa(); virtual int bb(); };
struct AA { int a; virtual int aa(); }; struct AA { int a; virtual int aa(); };
struct BB { int b; virtual int bb(); }; struct BB { int b; virtual int bb(); };
struct CC : AA, BB { virtual int aa(); virtual int bb(); virtual int cc(); }; struct CC : AA, BB { virtual int aa(); virtual int bb(); virtual int cc(); };
struct D : virtual C, virtual CC { int e; }; struct D : virtual C, virtual CC { int e; };
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

test/CodeGenCXX/virtual-base-ctor.cpp

// RUN: %clang_cc1 %s -emit-llvm -cxx-abi itanium -o - -O2 | FileCheck %s // RUN: %clang_cc1 %s -emit-llvm -triple %itanium_abi_triple -o - -O2 | FileCheck %s
struct B; struct B;
extern B x; extern B x;
char y; char y;
typedef __typeof(sizeof(int)) size_t; typedef __typeof(sizeof(int)) size_t;
struct A { int a; A() { y = ((size_t)this - (size_t)&x) / sizeof(void*); } }; struct A { int a; A() { y = ((size_t)this - (size_t)&x) / sizeof(void*); } };
struct B : virtual A { void* x; }; struct B : virtual A { void* x; };
B x; B x;
// CHECK: @y = global i8 2 // CHECK: @y = global i8 2

test/CodeGenCXX/virtual-base-destructor-call.cpp

// RUN: %clang_cc1 %s -cxx-abi itanium -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
struct basic_ios{~basic_ios(); }; struct basic_ios{~basic_ios(); };
template<typename _CharT> struct basic_istream : virtual public basic_ios { template<typename _CharT> struct basic_istream : virtual public basic_ios {
virtual ~basic_istream(){} virtual ~basic_istream(){}
}; };
template<typename _CharT> struct basic_iostream : public basic_istream<_CharT> template<typename _CharT> struct basic_iostream : public basic_istream<_CharT>
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/CodeGenCXX/virtual-destructor-synthesis.cpp

// RUN: %clang_cc1 %s -cxx-abi itanium -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
struct box { struct box {
virtual ~box(); virtual ~box();
}; };
struct pile_box : public box { struct pile_box : public box {
pile_box(box *); pile_box(box *);
}; };
pile_box::pile_box(box *pp) pile_box::pile_box(box *pp)
{ {
} }
// CHECK: call void @_ZdlPv // CHECK: call void @_ZdlPv

test/CodeGenCXX/virtual-function-calls.cpp

// RUN: %clang_cc1 %s -cxx-abi itanium -std=c++11 -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -triple %itanium_abi_triple -std=c++11 -emit-llvm -o - | FileCheck %s
// PR5021 // PR5021
namespace PR5021 { namespace PR5021 {
struct A { struct A {
virtual void f(char); virtual void f(char);
}; };
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/CodeGenCXX/virtual-implicit-copy-assignment.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
struct D; struct D;
struct B { struct B {
virtual D& operator = (const D&); virtual D& operator = (const D&);
}; };
struct D : B { D(); virtual void a(); }; struct D : B { D(); virtual void a(); };
void D::a() {} void D::a() {}
// CHECK: @_ZTV1D = {{.*}} @_ZN1DaSERKS_ // CHECK: @_ZTV1D = {{.*}} @_ZN1DaSERKS_
// CHECK: define linkonce_odr {{.*}} @_ZN1DaSERKS_ // CHECK: define linkonce_odr {{.*}} @_ZN1DaSERKS_

test/CodeGenCXX/virtual-implicit-move-assignment.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -std=c++11 -o - %s | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -std=c++11 -o - %s | FileCheck %s
struct D; struct D;
struct B { struct B {
virtual D &operator=(D&&) = 0; virtual D &operator=(D&&) = 0;
}; };
struct D : B { D(); virtual void a(); }; struct D : B { D(); virtual void a(); };
void D::a() {} void D::a() {}
D d; D d;
// CHECK: @_ZTV1D = {{.*}} @_ZN1DaSEOS_ // CHECK: @_ZTV1D = {{.*}} @_ZN1DaSEOS_
// CHECK: define linkonce_odr {{.*}} @_ZN1DaSEOS_ // CHECK: define linkonce_odr {{.*}} @_ZN1DaSEOS_

test/CodeGenCXX/virtual-inherited-destructor.cpp

// RUN: %clang_cc1 %s -cxx-abi itanium -emit-llvm-only // RUN: %clang_cc1 %s -triple %itanium_abi_triple -emit-llvm-only
struct A { virtual ~A(); }; struct A { virtual ~A(); };
struct B : A { struct B : A {
~B() { } ~B() { }
}; };
B x; B x;

test/CodeGenCXX/virtual-pseudo-destructor-call.cpp

// RUN: %clang_cc1 %s -cxx-abi itanium -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
struct A { struct A {
virtual ~A(); virtual ~A();
}; };
void f(A *a) { void f(A *a) {
// CHECK: define {{.*}} @_Z1fP1A // CHECK: define {{.*}} @_Z1fP1A
// CHECK: load // CHECK: load
// CHECK: load // CHECK: load
// CHECK: [[CALLEE:%[a-zA-Z0-9.]*]] = load // CHECK: [[CALLEE:%[a-zA-Z0-9.]*]] = load
// CHECK: call {{.*}} [[CALLEE]]( // CHECK: call {{.*}} [[CALLEE]](
a->~A(); a->~A();
} }

test/CodeGenCXX/visibility-hidden-extern-templates.cpp

// RUN: %clang_cc1 -O1 -cxx-abi itanium -emit-llvm -o - -fvisibility hidden %s | FileCheck %s // RUN: %clang_cc1 -O1 -triple %itanium_abi_triple -emit-llvm -o - -fvisibility hidden %s | FileCheck %s
template<typename T> template<typename T>
struct X { struct X {
void f(); void f();
void g() { } void g() { }
}; };
template<typename T> void X<T>::f() { } template<typename T> void X<T>::f() { }
Show All 17 Lines

test/CodeGenCXX/volatile-1.cpp

// RUN: %clang_cc1 -Wno-unused-value -cxx-abi itanium -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -Wno-unused-value -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck %s
// CHECK: @i = global [[INT:i[0-9]+]] 0 // CHECK: @i = global [[INT:i[0-9]+]] 0
volatile int i, j, k; volatile int i, j, k;
volatile int ar[5]; volatile int ar[5];
volatile char c; volatile char c;
// CHECK: @ci = global [[CINT:.*]] zeroinitializer // CHECK: @ci = global [[CINT:.*]] zeroinitializer
volatile _Complex int ci; volatile _Complex int ci;
volatile struct S { volatile struct S {
▲ Show 20 Lines • Show All 343 Lines • Show Last 20 Lines

test/CodeGenCXX/vtable-cast-crash.cpp

// RUN: %clang_cc1 -emit-llvm-only -cxx-abi itanium %s // RUN: %clang_cc1 -emit-llvm-only -triple %itanium_abi_triple %s
struct A struct A
{ {
A(); A();
virtual ~A(); virtual ~A();
}; };
struct B: A struct B: A
{ {
Show All 12 Lines

test/CodeGenCXX/weak-extern-typeinfo.cpp

// RUN: %clang_cc1 %s -emit-llvm -cxx-abi itanium -o - | FileCheck %s // RUN: %clang_cc1 %s -emit-llvm -triple %itanium_abi_triple -o - | FileCheck %s
// rdar://10246395 // rdar://10246395
#define WEAK __attribute__ ((weak)) #define WEAK __attribute__ ((weak))
class WEAK A { class WEAK A {
virtual void foo(); virtual void foo();
}; };
Show All 38 Lines

test/CodeGenCXX/weak-external.cpp

// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -cxx-abi itanium %s -S -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -triple %itanium_abi_triple %s -S -emit-llvm -o - | FileCheck %s
// PR4262 // PR4262
// CHECK-NOT: _ZNSs12_S_constructIPKcEEPcT_S3_RKSaIcESt20forward_iterator_tag // CHECK-NOT: _ZNSs12_S_constructIPKcEEPcT_S3_RKSaIcESt20forward_iterator_tag
// The "basic_string" extern template instantiation declaration is supposed to // The "basic_string" extern template instantiation declaration is supposed to
// suppress the implicit instantiation of non-inline member functions. Make sure // suppress the implicit instantiation of non-inline member functions. Make sure
// that we suppress the implicit instantiation of non-inline member functions // that we suppress the implicit instantiation of non-inline member functions
// defined out-of-line. That we aren't instantiating the basic_string // defined out-of-line. That we aren't instantiating the basic_string
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

test/CodeGenObjC/debug-info-self.m

// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -g %s -o - | FileCheck %s // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -g %s -o - | FileCheck %s
// self and _cmd are marked as DW_AT_artificial. // self and _cmd are marked as DW_AT_artificial.
// myarg is not marked as DW_AT_artificial. // myarg is not marked as DW_AT_artificial.
@interface MyClass { @interface MyClass {
} }
- (id)init:(int) myarg; - (id)init:(int) myarg;
@end @end
Show All 10 Lines

test/CodeGenObjC/overloadable.m

// rdar://6657613 // rdar://6657613
// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck %s
@class C; @class C;
// CHECK: _Z1fP11objc_object // CHECK: _Z1fP11objc_object
// CHECK-NOT: _Z1fP11objc_object // CHECK-NOT: _Z1fP11objc_object
void __attribute__((overloadable)) f(id c) { } void __attribute__((overloadable)) f(id c) { }
// CHECK: _Z1fP1C // CHECK: _Z1fP1C
// CHECK-NOT: _Z1fP1C // CHECK-NOT: _Z1fP1C
void __attribute__((overloadable)) f(C *c) { } void __attribute__((overloadable)) f(C *c) { }

test/CodeGenObjCXX/arc-mangle.mm

// RUN: %clang_cc1 -fobjc-arc -fobjc-runtime-has-weak -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -fobjc-arc -fobjc-runtime-has-weak -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
// CHECK-LABEL: define void @_Z1fPU8__strongP11objc_object(i8**) // CHECK-LABEL: define void @_Z1fPU8__strongP11objc_object(i8**)
void f(__strong id *) {} void f(__strong id *) {}
// CHECK-LABEL: define void @_Z1fPU6__weakP11objc_object(i8**) // CHECK-LABEL: define void @_Z1fPU6__weakP11objc_object(i8**)
void f(__weak id *) {} void f(__weak id *) {}
// CHECK-LABEL: define void @_Z1fPU15__autoreleasingP11objc_object(i8**) // CHECK-LABEL: define void @_Z1fPU15__autoreleasingP11objc_object(i8**)
void f(__autoreleasing id *) {} void f(__autoreleasing id *) {}
// CHECK-LABEL: define void @_Z1fPP11objc_object(i8**) // CHECK-LABEL: define void @_Z1fPP11objc_object(i8**)
Show All 16 Lines

test/CodeGenObjCXX/microsoft-abi-arc-param-order.mm

// RUN: %clang_cc1 -cxx-abi microsoft -mconstructor-aliases -fobjc-arc -triple i686-pc-win32 -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -mconstructor-aliases -fobjc-arc -triple i686-pc-win32 -emit-llvm -o - %s | FileCheck %s
struct A { struct A {
A(); A();
A(const A &); A(const A &);
~A(); ~A();
int a; int a;
}; };
Show All 11 Lines

test/CodeGenOpenCL/address-spaces-mangling.cl

// RUN: %clang_cc1 %s -ffake-address-space-map -faddress-space-map-mangling=yes -cxx-abi itanium -emit-llvm -o - | FileCheck -check-prefix=ASMANG %s // RUN: %clang_cc1 %s -ffake-address-space-map -faddress-space-map-mangling=yes -triple %itanium_abi_triple -emit-llvm -o - | FileCheck -check-prefix=ASMANG %s
// RUN: %clang_cc1 %s -ffake-address-space-map -faddress-space-map-mangling=no -cxx-abi itanium -emit-llvm -o - | FileCheck -check-prefix=NOASMANG %s // RUN: %clang_cc1 %s -ffake-address-space-map -faddress-space-map-mangling=no -triple %itanium_abi_triple -emit-llvm -o - | FileCheck -check-prefix=NOASMANG %s
// We can't name this f as private is equivalent to default // We can't name this f as private is equivalent to default
// no specifier given address space so we get multiple definition // no specifier given address space so we get multiple definition
// warnings, but we do want it for comparison purposes. // warnings, but we do want it for comparison purposes.
__attribute__((overloadable)) __attribute__((overloadable))
void ff(int *arg) { } void ff(int *arg) { }
// ASMANG: @_Z2ffPi // ASMANG: @_Z2ffPi
// NOASMANG: @_Z2ffPi // NOASMANG: @_Z2ffPi
Show All 20 Lines

test/CodeGenOpenCL/local.cl

// RUN: %clang_cc1 %s -ffake-address-space-map -faddress-space-map-mangling=no -cxx-abi itanium -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -ffake-address-space-map -faddress-space-map-mangling=no -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
__kernel void foo(void) { __kernel void foo(void) {
// CHECK: @foo.i = internal addrspace(2) // CHECK: @foo.i = internal addrspace(2)
__local int i; __local int i;
++i; ++i;
} }
// CHECK-LABEL: define void @_Z3barPU7CLlocali // CHECK-LABEL: define void @_Z3barPU7CLlocali
__kernel void __attribute__((__overloadable__)) bar(local int *x) { __kernel void __attribute__((__overloadable__)) bar(local int *x) {
*x = 5; *x = 5;
} }

test/Driver/cl.c

Show All 25 Lines
// CL: /help // CL: /help
// Options which are not "core" clang options nor cl.exe compatible options // Options which are not "core" clang options nor cl.exe compatible options
// are not available in clang-cl. // are not available in clang-cl.
// DEFAULT: -fapple-kext // DEFAULT: -fapple-kext
// CL-NOT: -fapple-kext // CL-NOT: -fapple-kext
// RUN: %clang_cl /c -### -- %s 2>&1 | FileCheck -check-prefix=COMPILE %s // RUN: %clang_cl /c -### -- %s 2>&1 | FileCheck -check-prefix=COMPILE %s
// COMPILE: "-cxx-abi" "microsoft"
// COMPILE: "-fdiagnostics-format" "msvc" // COMPILE: "-fdiagnostics-format" "msvc"

test/Layout/ms-x86-alias-avoidance-padding.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s -check-prefix CHECK-X64 // RUN: | FileCheck %s -check-prefix CHECK-X64
extern "C" int printf(const char *fmt, ...); extern "C" int printf(const char *fmt, ...);
__declspec(align(4096)) char buffer[4096]; __declspec(align(4096)) char buffer[4096];
struct AT {}; struct AT {};
struct V : AT { struct V : AT {
▲ Show 20 Lines • Show All 253 Lines • Show Last 20 Lines

test/Layout/ms-x86-aligned-tail-padding.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s -check-prefix CHECK-X64 // RUN: | FileCheck %s -check-prefix CHECK-X64
extern "C" int printf(const char *fmt, ...); extern "C" int printf(const char *fmt, ...);
struct B0 { struct B0 {
int a; int a;
B0() : a(0xf00000B0) {} B0() : a(0xf00000B0) {}
}; };
▲ Show 20 Lines • Show All 523 Lines • Show Last 20 Lines

test/Layout/ms-x86-basic-layout.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s -check-prefix CHECK-X64 // RUN: | FileCheck %s -check-prefix CHECK-X64
extern "C" int printf(const char *fmt, ...); extern "C" int printf(const char *fmt, ...);
struct A4 { struct A4 {
int a; int a;
A4() : a(0xf00000a4) {} A4() : a(0xf00000a4) {}
}; };
▲ Show 20 Lines • Show All 798 Lines • Show Last 20 Lines

test/Layout/ms-x86-bitfields-vbases.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>&1 \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s -check-prefix CHECK-X64 // RUN: | FileCheck %s -check-prefix CHECK-X64
struct B0 { int a; }; struct B0 { int a; };
struct B1 { int a; }; struct B1 { int a; };
struct A : virtual B0 { char a : 1; }; struct A : virtual B0 { char a : 1; };
// CHECK: *** Dumping AST Record Layout // CHECK: *** Dumping AST Record Layout
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

test/Layout/ms-x86-empty-base-after-base-with-vbptr.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts %s 2>/dev/null \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts %s 2>/dev/null \
// RUN: | FileCheck %s -check-prefix CHECK-X64 // RUN: | FileCheck %s -check-prefix CHECK-X64
struct U { char a; }; struct U { char a; };
struct V { }; struct V { };
struct W { }; struct W { };
struct X : virtual V { char a; }; struct X : virtual V { char a; };
struct Y : virtual V { char a; }; struct Y : virtual V { char a; };
▲ Show 20 Lines • Show All 217 Lines • Show Last 20 Lines

test/Layout/ms-x86-empty-nonvirtual-bases.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s // RUN: | FileCheck %s
extern "C" int printf(const char *fmt, ...); extern "C" int printf(const char *fmt, ...);
struct __declspec(align(8)) B0 { B0() {printf("B0 : %p\n", this);} }; struct __declspec(align(8)) B0 { B0() {printf("B0 : %p\n", this);} };
struct __declspec(align(8)) B1 { B1() {printf("B1 : %p\n", this);} }; struct __declspec(align(8)) B1 { B1() {printf("B1 : %p\n", this);} };
struct __declspec(align(8)) B2 { B2() {printf("B2 : %p\n", this);} }; struct __declspec(align(8)) B2 { B2() {printf("B2 : %p\n", this);} };
struct __declspec(align(8)) B3 { B3() {printf("B3 : %p\n", this);} }; struct __declspec(align(8)) B3 { B3() {printf("B3 : %p\n", this);} };
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

test/Layout/ms-x86-empty-virtual-base.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s -check-prefix CHECK-X64 // RUN: | FileCheck %s -check-prefix CHECK-X64
extern "C" int printf(const char *fmt, ...); extern "C" int printf(const char *fmt, ...);
struct __declspec(align(8)) B0 { B0() {printf("B0 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} }; struct __declspec(align(8)) B0 { B0() {printf("B0 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} };
struct __declspec(align(8)) B1 { B1() {printf("B1 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} }; struct __declspec(align(8)) B1 { B1() {printf("B1 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} };
struct __declspec(align(8)) B2 { B2() {printf("B2 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} }; struct __declspec(align(8)) B2 { B2() {printf("B2 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} };
struct __declspec(align(8)) B3 { B3() {printf("B3 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} }; struct __declspec(align(8)) B3 { B3() {printf("B3 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} };
▲ Show 20 Lines • Show All 740 Lines • ▼ Show 20 Lines
sizeof(O)+ sizeof(O)+
sizeof(P)+ sizeof(P)+
sizeof(Q)+ sizeof(Q)+
sizeof(R)+ sizeof(R)+
sizeof(S)+ sizeof(S)+
sizeof(T)+ sizeof(T)+
sizeof(U)+ sizeof(U)+
sizeof(V)+ sizeof(V)+
sizeof(T3)]; sizeof(T3)];
No newline at end of file

test/Layout/ms-x86-lazy-empty-nonvirtual-base.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s -check-prefix CHECK-X64 // RUN: | FileCheck %s -check-prefix CHECK-X64
extern "C" int printf(const char *fmt, ...); extern "C" int printf(const char *fmt, ...);
struct B0 { B0() { printf("B0 = %p\n", this); } }; struct B0 { B0() { printf("B0 = %p\n", this); } };
struct B1 { B1() { printf("B1 = %p\n", this); } }; struct B1 { B1() { printf("B1 = %p\n", this); } };
struct B2 { B2() { printf("B2 = %p\n", this); } }; struct B2 { B2() { printf("B2 = %p\n", this); } };
struct B3 { B3() { printf("B3 = %p\n", this); } }; struct B3 { B3() { printf("B3 = %p\n", this); } };
▲ Show 20 Lines • Show All 785 Lines • Show Last 20 Lines

test/Layout/ms-x86-misalignedarray.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>&1 \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s -check-prefix CHECK-X64 // RUN: | FileCheck %s -check-prefix CHECK-X64
struct T0 { char c; }; struct T0 { char c; };
struct T2 : virtual T0 { }; struct T2 : virtual T0 { };
struct T3 { T2 a[1]; char c; }; struct T3 { T2 a[1]; char c; };
// CHECK: *** Dumping AST Record Layout // CHECK: *** Dumping AST Record Layout
// CHECK: *** Dumping AST Record Layout // CHECK: *** Dumping AST Record Layout
Show All 16 Lines

test/Layout/ms-x86-pack-and-align.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>&1 \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s -check-prefix CHECK-X64 // RUN: | FileCheck %s -check-prefix CHECK-X64
extern "C" int printf(const char *fmt, ...); extern "C" int printf(const char *fmt, ...);
char buffer[419430400]; char buffer[419430400];
struct A { struct A {
char a; char a;
A() { A() {
▲ Show 20 Lines • Show All 327 Lines • Show Last 20 Lines

test/Layout/ms-x86-primary-bases.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s -check-prefix CHECK-X64 // RUN: | FileCheck %s -check-prefix CHECK-X64
extern "C" int printf(const char *fmt, ...); extern "C" int printf(const char *fmt, ...);
struct B0 { int a; B0() : a(0xf00000B0) { printf("B0 = %p\n", this); } virtual void f() { printf("B0"); } }; struct B0 { int a; B0() : a(0xf00000B0) { printf("B0 = %p\n", this); } virtual void f() { printf("B0"); } };
struct B1 { int a; B1() : a(0xf00000B1) { printf("B1 = %p\n", this); } virtual void g() { printf("B1"); } }; struct B1 { int a; B1() : a(0xf00000B1) { printf("B1 = %p\n", this); } virtual void g() { printf("B1"); } };
struct B2 { int a; B2() : a(0xf00000B2) { printf("B1 = %p\n", this); } }; struct B2 { int a; B2() : a(0xf00000B2) { printf("B1 = %p\n", this); } };
struct B0X { int a; B0X() : a(0xf00000B0) {} }; struct B0X { int a; B0X() : a(0xf00000B0) {} };
▲ Show 20 Lines • Show All 319 Lines • Show Last 20 Lines

test/Layout/ms-x86-size-alignment-fail.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts %s 2>/dev/null \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts %s 2>/dev/null \
// RUN: | FileCheck %s -check-prefix CHECK-X64 // RUN: | FileCheck %s -check-prefix CHECK-X64
extern "C" int printf(const char *fmt, ...); extern "C" int printf(const char *fmt, ...);
struct B0 { char a; B0() : a(0xB0) {} }; struct B0 { char a; B0() : a(0xB0) {} };
struct __declspec(align(1)) B1 {}; struct __declspec(align(1)) B1 {};
struct A : virtual B0 {}; struct A : virtual B0 {};
▲ Show 20 Lines • Show All 116 Lines • Show Last 20 Lines

test/Layout/ms-x86-vfvb-alignment.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>&1 \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s -check-prefix CHECK-X64 // RUN: | FileCheck %s -check-prefix CHECK-X64
extern "C" int printf(const char *fmt, ...); extern "C" int printf(const char *fmt, ...);
struct B0 { int a; B0() : a(0xf00000B0) {} }; struct B0 { int a; B0() : a(0xf00000B0) {} };
struct B1 { char a; B1() : a(0xB1) {} }; struct B1 { char a; B1() : a(0xB1) {} };
struct B2 : virtual B1 { int a; B2() : a(0xf00000B2) {} }; struct B2 : virtual B1 { int a; B2() : a(0xf00000B2) {} };
struct B3 { __declspec(align(16)) int a; B3() : a(0xf00000B3) {} }; struct B3 { __declspec(align(16)) int a; B3() : a(0xf00000B3) {} };
▲ Show 20 Lines • Show All 377 Lines • Show Last 20 Lines

test/Layout/ms-x86-vfvb-sharing.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>&1 \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s -check-prefix CHECK-X64 // RUN: | FileCheck %s -check-prefix CHECK-X64
extern "C" int printf(const char *fmt, ...); extern "C" int printf(const char *fmt, ...);
struct B0 { int a; B0() : a(0xf00000B0) { printf("B0 = %p\n", this); } }; struct B0 { int a; B0() : a(0xf00000B0) { printf("B0 = %p\n", this); } };
struct B1 { int a; B1() : a(0xf00000B1) { printf("B1 = %p\n", this); } }; struct B1 { int a; B1() : a(0xf00000B1) { printf("B1 = %p\n", this); } };
struct B2 { B2() { printf("B2 = %p\n", this); } virtual void g() { printf("B2"); } }; struct B2 { B2() { printf("B2 = %p\n", this); } virtual void g() { printf("B2"); } };
struct B3 : virtual B1 { B3() { printf("B3 = %p\n", this); } }; struct B3 : virtual B1 { B3() { printf("B3 = %p\n", this); } };
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

test/Layout/ms-x86-vtordisp.cpp

// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>&1 \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
// RUN: | FileCheck %s -check-prefix CHECK-X64 // RUN: | FileCheck %s -check-prefix CHECK-X64
extern "C" int printf(const char *fmt, ...); extern "C" int printf(const char *fmt, ...);
struct B0 { struct B0 {
int a; int a;
B0() : a(0xf00000B0) {} B0() : a(0xf00000B0) {}
virtual void f() { printf("B0"); } virtual void f() { printf("B0"); }
▲ Show 20 Lines • Show All 211 Lines • Show Last 20 Lines

test/PCH/cxx-reference.cpp

// Test this without pch. // Test this without pch.
// RUN: %clang_cc1 -x c++ -cxx-abi itanium -std=c++11 -include %S/cxx-reference.h -fsyntax-only -emit-llvm -o - %s // RUN: %clang_cc1 -x c++ -triple %itanium_abi_triple -std=c++11 -include %S/cxx-reference.h -fsyntax-only -emit-llvm -o - %s
// Test with pch. // Test with pch.
// RUN: %clang_cc1 -x c++ -cxx-abi itanium -std=c++11 -emit-pch -o %t %S/cxx-reference.h // RUN: %clang_cc1 -x c++ -triple %itanium_abi_triple -std=c++11 -emit-pch -o %t %S/cxx-reference.h
// RUN: %clang_cc1 -x c++ -cxx-abi itanium -std=c++11 -include-pch %t -fsyntax-only -emit-llvm -o - %s // RUN: %clang_cc1 -x c++ -triple %itanium_abi_triple -std=c++11 -include-pch %t -fsyntax-only -emit-llvm -o - %s

test/PCH/cxx-required-decls.cpp

// Test this without pch. // Test this without pch.
// RUN: %clang_cc1 -include %S/cxx-required-decls.h %s -cxx-abi itanium -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 -include %S/cxx-required-decls.h %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
// Test with pch. // Test with pch.
// RUN: %clang_cc1 -x c++-header -cxx-abi itanium -emit-pch -o %t %S/cxx-required-decls.h // RUN: %clang_cc1 -x c++-header -triple %itanium_abi_triple -emit-pch -o %t %S/cxx-required-decls.h
// RUN: %clang_cc1 -include-pch %t %s -cxx-abi itanium -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 -include-pch %t %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
// CHECK: @_ZL5globS = internal global %struct.S zeroinitializer // CHECK: @_ZL5globS = internal global %struct.S zeroinitializer
// CHECK: @_ZL3bar = internal global i32 0, align 4 // CHECK: @_ZL3bar = internal global i32 0, align 4
// CHECK: @glob_var = global i32 0 // CHECK: @glob_var = global i32 0

test/PCH/cxx-templates.cpp

// Test this without pch. // Test this without pch.
// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fexceptions -include %S/cxx-templates.h -verify %s -ast-dump -o - // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -include %S/cxx-templates.h -verify %s -ast-dump -o -
// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fexceptions -include %S/cxx-templates.h %s -emit-llvm -o - -DNO_ERRORS | FileCheck %s // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -include %S/cxx-templates.h %s -emit-llvm -o - -DNO_ERRORS | FileCheck %s
// Test with pch. // Test with pch.
// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fexceptions -x c++-header -emit-pch -o %t %S/cxx-templates.h // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -x c++-header -emit-pch -o %t %S/cxx-templates.h
// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fexceptions -include-pch %t -verify %s -ast-dump -o - // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -include-pch %t -verify %s -ast-dump -o -
// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fexceptions -include-pch %t %s -emit-llvm -o - -error-on-deserialized-decl doNotDeserialize -DNO_ERRORS | FileCheck %s // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -include-pch %t %s -emit-llvm -o - -error-on-deserialized-decl doNotDeserialize -DNO_ERRORS | FileCheck %s
// Test with modules. // Test with modules.
// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fexceptions -fmodules -x c++-header -emit-pch -o %t %S/cxx-templates.h // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -fmodules -x c++-header -emit-pch -o %t %S/cxx-templates.h
// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fexceptions -fmodules -include-pch %t -verify %s -ast-dump -o - // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -fmodules -include-pch %t -verify %s -ast-dump -o -
// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fexceptions -fmodules -include-pch %t %s -emit-llvm -o - -error-on-deserialized-decl doNotDeserialize -DNO_ERRORS | FileCheck %s // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -fmodules -include-pch %t %s -emit-llvm -o - -error-on-deserialized-decl doNotDeserialize -DNO_ERRORS | FileCheck %s
// Test with pch and delayed template parsing. // Test with pch and delayed template parsing.
// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fdelayed-template-parsing -fexceptions -x c++-header -emit-pch -o %t %S/cxx-templates.h // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fdelayed-template-parsing -fexceptions -x c++-header -emit-pch -o %t %S/cxx-templates.h
// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fdelayed-template-parsing -fexceptions -include-pch %t -verify %s -ast-dump -o - // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fdelayed-template-parsing -fexceptions -include-pch %t -verify %s -ast-dump -o -
// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fdelayed-template-parsing -fexceptions -include-pch %t %s -emit-llvm -o - -DNO_ERRORS | FileCheck %s // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fdelayed-template-parsing -fexceptions -include-pch %t %s -emit-llvm -o - -DNO_ERRORS | FileCheck %s
// CHECK: define weak_odr {{.*}}void @_ZN2S4IiE1mEv // CHECK: define weak_odr {{.*}}void @_ZN2S4IiE1mEv
// CHECK: define linkonce_odr {{.*}}void @_ZN2S3IiE1mEv // CHECK: define linkonce_odr {{.*}}void @_ZN2S3IiE1mEv
struct A { struct A {
typedef int type; typedef int type;
static void my_f(); static void my_f();
template <typename T> template <typename T>
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

test/PCH/irgen-rdar13114142.mm

// RUN: %clang_cc1 %s -cxx-abi itanium -emit-pch -o %t.pch // RUN: %clang_cc1 %s -triple %itanium_abi_triple -emit-pch -o %t.pch
// RUN: %clang_cc1 %s -cxx-abi itanium -emit-llvm -include-pch %t.pch -o - | FileCheck %s // RUN: %clang_cc1 %s -triple %itanium_abi_triple -emit-llvm -include-pch %t.pch -o - | FileCheck %s
#ifndef HEADER #ifndef HEADER
#define HEADER #define HEADER
class OOArray{ class OOArray{
public: public:
~OOArray(); ~OOArray();
}; };
Show All 29 Lines

test/PCH/objc_literals.mm

// RUN: %clang_cc1 -cxx-abi itanium -emit-pch -x objective-c++ -std=c++0x -o %t %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-pch -x objective-c++ -std=c++0x -o %t %s
// RUN: %clang_cc1 -cxx-abi itanium -include-pch %t -x objective-c++ -std=c++0x -verify %s // RUN: %clang_cc1 -triple %itanium_abi_triple -include-pch %t -x objective-c++ -std=c++0x -verify %s
// RUN: %clang_cc1 -cxx-abi itanium -include-pch %t -x objective-c++ -std=c++0x -ast-print %s | FileCheck -check-prefix=CHECK-PRINT %s // RUN: %clang_cc1 -triple %itanium_abi_triple -include-pch %t -x objective-c++ -std=c++0x -ast-print %s | FileCheck -check-prefix=CHECK-PRINT %s
// RUN: %clang_cc1 -cxx-abi itanium -include-pch %t -x objective-c++ -std=c++0x -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-IR %s // RUN: %clang_cc1 -triple %itanium_abi_triple -include-pch %t -x objective-c++ -std=c++0x -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-IR %s
// expected-no-diagnostics // expected-no-diagnostics
#ifndef HEADER #ifndef HEADER
#define HEADER #define HEADER
typedef unsigned char BOOL; typedef unsigned char BOOL;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/PCH/objcxx-ivar-class.mm

// Test this without pch. // Test this without pch.
// RUN: %clang_cc1 -include %S/objcxx-ivar-class.h -cxx-abi itanium %s -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 -include %S/objcxx-ivar-class.h -triple %itanium_abi_triple %s -emit-llvm -o - | FileCheck %s
// Test with pch. // Test with pch.
// RUN: %clang_cc1 -x objective-c++-header -cxx-abi itanium -emit-pch -o %t %S/objcxx-ivar-class.h // RUN: %clang_cc1 -x objective-c++-header -triple %itanium_abi_triple -emit-pch -o %t %S/objcxx-ivar-class.h
// RUN: %clang_cc1 -include-pch %t -cxx-abi itanium %s -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 -include-pch %t -triple %itanium_abi_triple %s -emit-llvm -o - | FileCheck %s
// CHECK: [C position] // CHECK: [C position]
// CHECK: call {{.*}} @_ZN1SC1ERKS_ // CHECK: call {{.*}} @_ZN1SC1ERKS_
// CHECK: [C setPosition:] // CHECK: [C setPosition:]
// CHECK: = call {{.*}}%struct.S* @_ZN1SaSERKS_ // CHECK: = call {{.*}}%struct.S* @_ZN1SaSERKS_
// CHECK: [C .cxx_destruct] // CHECK: [C .cxx_destruct]
// CHECK: [C .cxx_construct] // CHECK: [C .cxx_construct]

test/Sema/empty1.c

// RUN: %clang_cc1 %s -cxx-abi itanium -fsyntax-only -verify -Wc++-compat // RUN: %clang_cc1 %s -triple %itanium_abi_triple -fsyntax-only -verify -Wc++-compat
// FIXME: Empty C structs are 4 bytes in MSVC, but the -cxx-abi flag probably // Note: Empty C structs are 4 bytes in the Microsoft ABI.
// shouldn't affect this since it's not C++. PR18263.
struct emp_1 { // expected-warning {{empty struct has size 0 in C, size 1 in C++}} struct emp_1 { // expected-warning {{empty struct has size 0 in C, size 1 in C++}}
}; };
union emp_2 { // expected-warning {{empty union has size 0 in C, size 1 in C++}} union emp_2 { // expected-warning {{empty union has size 0 in C, size 1 in C++}}
}; };
struct emp_3 { // expected-warning {{struct has size 0 in C, size 1 in C++}} struct emp_3 { // expected-warning {{struct has size 0 in C, size 1 in C++}}
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

test/Sema/ms_bitfield_layout.c

// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -cxx-abi microsoft -fdump-record-layouts %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts %s 2>/dev/null \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -cxx-abi microsoft -fdump-record-layouts %s 2>/dev/null \ // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts %s 2>/dev/null \
// RUN: | FileCheck %s // RUN: | FileCheck %s
typedef struct A { typedef struct A {
char x; char x;
int a : 22; int a : 22;
int : 0; int : 0;
int c : 10; int c : 10;
char b : 3; char b : 3;
▲ Show 20 Lines • Show All 232 Lines • Show Last 20 Lines

test/Sema/ms_class_layout.cpp

// RUN: %clang_cc1 -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -cxx-abi microsoft %s 2>&1 \ // RUN: %clang_cc1 -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts %s 2>&1 \
// RUN: | FileCheck %s // RUN: | FileCheck %s
#pragma pack(push, 8) #pragma pack(push, 8)
class B { class B {
public: public:
virtual void b(){} virtual void b(){}
int b_field; int b_field;
▲ Show 20 Lines • Show All 499 Lines • Show Last 20 Lines

test/SemaCXX/calling-conv-compat.cpp

// RUN: %clang_cc1 -fsyntax-only -std=c++11 -fms-extensions -cxx-abi microsoft -verify -triple i686-pc-win32 %s // RUN: %clang_cc1 -fsyntax-only -std=c++11 -fms-extensions -verify -triple i686-pc-win32 %s
// Pointers to free functions // Pointers to free functions
void free_func_default(); void free_func_default();
void __cdecl free_func_cdecl(); void __cdecl free_func_cdecl();
void __stdcall free_func_stdcall(); void __stdcall free_func_stdcall();
void __fastcall free_func_fastcall(); void __fastcall free_func_fastcall();
typedef void ( *fptr_default)(); typedef void ( *fptr_default)();
▲ Show 20 Lines • Show All 379 Lines • Show Last 20 Lines

test/SemaCXX/decl-microsoft-call-conv.cpp

// RUN: %clang_cc1 -triple i686-pc-win32 -cxx-abi microsoft -fms-extensions -verify %s // RUN: %clang_cc1 -triple i686-pc-win32 -fms-extensions -verify %s
typedef void void_fun_t(); typedef void void_fun_t();
typedef void __cdecl cdecl_fun_t(); typedef void __cdecl cdecl_fun_t();
// Pointers to free functions // Pointers to free functions
void free_func_default(); // expected-note 2 {{previous declaration is here}} void free_func_default(); // expected-note 2 {{previous declaration is here}}
void __cdecl free_func_cdecl(); // expected-note 2 {{previous declaration is here}} void __cdecl free_func_cdecl(); // expected-note 2 {{previous declaration is here}}
void __stdcall free_func_stdcall(); // expected-note 2 {{previous declaration is here}} void __stdcall free_func_stdcall(); // expected-note 2 {{previous declaration is here}}
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines

test/SemaCXX/destructor.cpp

// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fsyntax-only -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -verify %s // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fsyntax-only -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -verify %s
// RUN: %clang_cc1 -std=c++11 -cxx-abi microsoft -DMSABI -fsyntax-only -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -verify %s // RUN: %clang_cc1 -std=c++11 -triple %ms_abi_triple -DMSABI -fsyntax-only -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -verify %s
class A { class A {
public: public:
~A(); ~A();
}; };
class B { class B {
public: public:
~B() { } ~B() { }
▲ Show 20 Lines • Show All 372 Lines • Show Last 20 Lines

test/SemaCXX/implicit-virtual-member-functions.cpp

// RUN: %clang_cc1 -fsyntax-only -cxx-abi itanium -verify %s // RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify %s
// RUN: %clang_cc1 -fsyntax-only -cxx-abi microsoft -DMSABI -verify %s // RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify %s
struct A { struct A {
virtual ~A(); virtual ~A();
}; };
struct B : A { // expected-error {{no suitable member 'operator delete' in 'B'}} struct B : A { // expected-error {{no suitable member 'operator delete' in 'B'}}
virtual void f(); virtual void f();
void operator delete (void *, int); // expected-note {{'operator delete' declared here}} void operator delete (void *, int); // expected-note {{'operator delete' declared here}}
Show All 23 Lines

test/SemaCXX/member-pointer-ms.cpp

// RUN: %clang_cc1 -std=c++11 -cxx-abi microsoft -fms-compatibility -fsyntax-only -triple=i386-pc-win32 -verify %s // RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=i386-pc-win32 -verify %s
// RUN: %clang_cc1 -std=c++11 -cxx-abi microsoft -fms-compatibility -fsyntax-only -triple=x86_64-pc-win32 -verify %s // RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=x86_64-pc-win32 -verify %s
// //
// This file should also give no diagnostics when run through cl.exe from MSVS // This file should also give no diagnostics when run through cl.exe from MSVS
// 2012, which supports C++11 and static_assert. It should pass for both 64-bit // 2012, which supports C++11 and static_assert. It should pass for both 64-bit
// and 32-bit x86. // and 32-bit x86.
// //
// Test the size of various member pointer combinations: // Test the size of various member pointer combinations:
// - complete and incomplete // - complete and incomplete
// - single, multiple, and virtual inheritance (and unspecified for incomplete) // - single, multiple, and virtual inheritance (and unspecified for incomplete)
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

test/SemaCXX/microsoft-dtor-lookup-cxx11.cpp

// RUN: %clang_cc1 -triple i686-pc-win32 -cxx-abi microsoft -std=c++11 -verify %s // RUN: %clang_cc1 -triple i686-pc-win32 -std=c++11 -verify %s
struct S { struct S {
virtual ~S() = delete; // expected-note {{'~S' has been explicitly marked deleted here}} virtual ~S() = delete; // expected-note {{'~S' has been explicitly marked deleted here}}
void operator delete(void*, int); void operator delete(void*, int);
void operator delete(void*, double); void operator delete(void*, double);
} s; // expected-error {{attempt to use a deleted function}} } s; // expected-error {{attempt to use a deleted function}}
struct T { // expected-note{{virtual destructor requires an unambiguous, accessible 'operator delete'}} struct T { // expected-note{{virtual destructor requires an unambiguous, accessible 'operator delete'}}
virtual ~T() = default; // expected-note {{explicitly defaulted function was implicitly deleted here}} virtual ~T() = default; // expected-note {{explicitly defaulted function was implicitly deleted here}}
void operator delete(void*, int); void operator delete(void*, int);
void operator delete(void*, double); void operator delete(void*, double);
} t; // expected-error {{attempt to use a deleted function}} } t; // expected-error {{attempt to use a deleted function}}

test/SemaCXX/microsoft-dtor-lookup.cpp

// RUN: %clang_cc1 -triple i686-pc-win32 -cxx-abi itanium -fsyntax-only %s // RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only %s
// RUN: %clang_cc1 -triple i686-pc-win32 -cxx-abi microsoft -verify -DMSVC_ABI %s // RUN: %clang_cc1 -triple %ms_abi_triple -verify -DMSVC_ABI %s
namespace Test1 { namespace Test1 {
// Should be accepted under the Itanium ABI (first RUN line) but rejected // Should be accepted under the Itanium ABI (first RUN line) but rejected
// under the Microsoft ABI (second RUN line), as Microsoft ABI requires // under the Microsoft ABI (second RUN line), as Microsoft ABI requires
// operator delete() lookups to be done at all virtual destructor declaration // operator delete() lookups to be done at all virtual destructor declaration
// points. // points.
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

test/SemaCXX/primary-base.cpp

// RUN: %clang_cc1 -cxx-abi itanium -fsyntax-only -verify %s // RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -verify %s
// expected-no-diagnostics // expected-no-diagnostics
class A { virtual void f(); }; class A { virtual void f(); };
class B : virtual A { }; class B : virtual A { };
class C : B { }; class C : B { };
// Since A is already a primary base class, C should be the primary base class // Since A is already a primary base class, C should be the primary base class
// of F. // of F.
class F : virtual A, virtual C { }; class F : virtual A, virtual C { };
int sa[sizeof(F) == sizeof(A) ? 1 : -1]; int sa[sizeof(F) == sizeof(A) ? 1 : -1];

test/SemaCXX/typeid-ref.cpp

// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
namespace std { namespace std {
class type_info; class type_info;
} }
struct X { }; struct X { };
void f() { void f() {
// CHECK: @_ZTS1X = linkonce_odr constant // CHECK: @_ZTS1X = linkonce_odr constant
// CHECK: @_ZTI1X = linkonce_odr unnamed_addr constant // CHECK: @_ZTI1X = linkonce_odr unnamed_addr constant
(void)typeid(X&); (void)typeid(X&);
} }

test/SemaCXX/undefined-internal.cpp

// RUN: %clang_cc1 -fsyntax-only -verify %s // RUN: %clang_cc1 -fsyntax-only -verify %s
// Make sure we don't produce invalid IR. // Make sure we don't produce invalid IR.
// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm-only %s // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm-only %s
// FIXME: -cxx-abi itanium shouldn't be necessary; the test should pass // FIXME: Itanium shouldn't be necessary; the test should pass
// in MS mode too. // in MS mode too.
namespace test1 { namespace test1 {
static void foo(); // expected-warning {{function 'test1::foo' has internal linkage but is not defined}} static void foo(); // expected-warning {{function 'test1::foo' has internal linkage but is not defined}}
template <class T> static void bar(); // expected-warning {{function 'test1::bar<int>' has internal linkage but is not defined}} template <class T> static void bar(); // expected-warning {{function 'test1::bar<int>' has internal linkage but is not defined}}
void test() { void test() {
foo(); // expected-note {{used here}} foo(); // expected-note {{used here}}
▲ Show 20 Lines • Show All 321 Lines • Show Last 20 Lines

test/SemaCXX/virtual-base-used.cpp

// RUN: %clang_cc1 -fsyntax-only -cxx-abi itanium -verify %s // RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify %s
// RUN: %clang_cc1 -fsyntax-only -cxx-abi microsoft -DMSABI -verify %s // RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify %s
// PR7800 // PR7800
// The Microsoft ABI doesn't have the concept of key functions, so we have different // The Microsoft ABI doesn't have the concept of key functions, so we have different
// expectations about when functions are first required for that case. // expectations about when functions are first required for that case.
#ifdef MSABI #ifdef MSABI
// expected-note@+2 3 {{declared private here}} // expected-note@+2 3 {{declared private here}}
#endif #endif
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

test/SemaCXX/virtual-override-x86.cpp

// RUN: %clang_cc1 -triple=i686-pc-unknown -fsyntax-only -verify %s -std=c++11 -cxx-abi microsoft // RUN: %clang_cc1 -triple=i686-pc-win32 -fsyntax-only -verify %s -std=c++11
namespace PR14339 { namespace PR14339 {
class A { class A {
public: public:
virtual void __attribute__((thiscall)) f(); // expected-note{{overridden virtual function is here}} virtual void __attribute__((thiscall)) f(); // expected-note{{overridden virtual function is here}}
}; };
class B : public A { class B : public A {
Show All 24 Lines

test/SemaCXX/virtual-override.cpp

// RUN: %clang_cc1 -fsyntax-only -cxx-abi itanium -verify %s -std=c++11 // RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify %s -std=c++11
// RUN: %clang_cc1 -fsyntax-only -cxx-abi microsoft -verify %s -std=c++11 // RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -verify %s -std=c++11
namespace T1 { namespace T1 {
class A { class A {
virtual int f(); // expected-note{{overridden virtual function is here}} virtual int f(); // expected-note{{overridden virtual function is here}}
}; };
class B : A { class B : A {
virtual void f(); // expected-error{{virtual function 'f' has a different return type ('void') than the function it overrides (which has return type 'int')}} virtual void f(); // expected-error{{virtual function 'f' has a different return type ('void') than the function it overrides (which has return type 'int')}}
▲ Show 20 Lines • Show All 281 Lines • Show Last 20 Lines

test/SemaCXX/warn-reinterpret-base-class.cpp

// RUN: %clang_cc1 -std=c++11 -fsyntax-only -cxx-abi itanium -verify -Wreinterpret-base-class -Wno-unused-volatile-lvalue %s // RUN: %clang_cc1 -std=c++11 -fsyntax-only -triple %itanium_abi_triple -verify -Wreinterpret-base-class -Wno-unused-volatile-lvalue %s
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -cxx-abi microsoft -DMSABI -verify -Wreinterpret-base-class -Wno-unused-volatile-lvalue %s // RUN: %clang_cc1 -std=c++11 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify -Wreinterpret-base-class -Wno-unused-volatile-lvalue %s
// RUN: not %clang_cc1 -std=c++11 -fsyntax-only -cxx-abi itanium -fdiagnostics-parseable-fixits -Wreinterpret-base-class -Wno-unused-volatile-lvalue %s 2>&1 | FileCheck %s // RUN: not %clang_cc1 -std=c++11 -fsyntax-only -triple %itanium_abi_triple -fdiagnostics-parseable-fixits -Wreinterpret-base-class -Wno-unused-volatile-lvalue %s 2>&1 | FileCheck %s
// RUN: not %clang_cc1 -std=c++11 -fsyntax-only -cxx-abi microsoft -fdiagnostics-parseable-fixits -Wreinterpret-base-class -Wno-unused-volatile-lvalue %s 2>&1 | FileCheck %s // RUN: not %clang_cc1 -std=c++11 -fsyntax-only -triple %ms_abi_triple -fdiagnostics-parseable-fixits -Wreinterpret-base-class -Wno-unused-volatile-lvalue %s 2>&1 | FileCheck %s
// PR 13824 // PR 13824
class A { class A {
}; };
class DA : public A { class DA : public A {
}; };
class DDA : public DA { class DDA : public DA {
}; };
▲ Show 20 Lines • Show All 324 Lines • Show Last 20 Lines

test/SemaCXX/warn-weak-vtables.cpp

// RUN: %clang_cc1 %s -fsyntax-only -verify -cxx-abi itanium -Wweak-vtables -Wweak-template-vtables // RUN: %clang_cc1 %s -fsyntax-only -verify -triple %itanium_abi_triple -Wweak-vtables -Wweak-template-vtables
// RUN: %clang_cc1 %s -fsyntax-only -cxx-abi microsoft -Werror -Wno-weak-vtables -Wno-weak-template-vtables // RUN: %clang_cc1 %s -fsyntax-only -triple %ms_abi_triple -Werror -Wno-weak-vtables -Wno-weak-template-vtables
struct A { // expected-warning {{'A' has no out-of-line virtual method definitions; its vtable will be emitted in every translation unit}} struct A { // expected-warning {{'A' has no out-of-line virtual method definitions; its vtable will be emitted in every translation unit}}
virtual void f() { } virtual void f() { }
}; };
template<typename T> struct B { template<typename T> struct B {
virtual void f() { } virtual void f() { }
}; };
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

test/SemaObjCXX/microsoft-abi-byval.mm

// RUN: %clang_cc1 -fsyntax-only -verify -cxx-abi microsoft -Wno-objc-root-class %s // RUN: %clang_cc1 -fsyntax-only -verify -triple %ms_abi_triple -Wno-objc-root-class %s
// expected-no-diagnostics // expected-no-diagnostics
class Foo { class Foo {
~Foo(); ~Foo();
}; };
@interface bar @interface bar
- (void) my_method: (Foo)arg; - (void) my_method: (Foo)arg;
@end @end
@implementation bar @implementation bar
- (void) my_method: (Foo)arg { // no error; MS ABI will call Foo's dtor, but we skip the access check. - (void) my_method: (Foo)arg { // no error; MS ABI will call Foo's dtor, but we skip the access check.
} }
@end @end

test/SemaTemplate/inject-templated-friend-post.cpp

// RUN: %clang_cc1 %s -std=c++98 -cxx-abi itanium -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -std=c++98 -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 %s -std=c++98 -cxx-abi itanium -emit-llvm -o - -DPROTOTYPE | FileCheck --check-prefix=CHECK-PROTOTYPE %s // RUN: %clang_cc1 %s -std=c++98 -triple %itanium_abi_triple -emit-llvm -o - -DPROTOTYPE | FileCheck --check-prefix=CHECK-PROTOTYPE %s
// RUN: %clang_cc1 %s -std=c++98 -cxx-abi itanium -emit-llvm -o - -DINSTANTIATE | FileCheck --check-prefix=CHECK-INSTANTIATE %s // RUN: %clang_cc1 %s -std=c++98 -triple %itanium_abi_triple -emit-llvm -o - -DINSTANTIATE | FileCheck --check-prefix=CHECK-INSTANTIATE %s
// RUN: %clang_cc1 %s -std=c++98 -cxx-abi itanium -emit-llvm -o - -DPROTOTYPE -DINSTANTIATE | FileCheck --check-prefix=CHECK-PROTOTYPE-INSTANTIATE %s // RUN: %clang_cc1 %s -std=c++98 -triple %itanium_abi_triple -emit-llvm -o - -DPROTOTYPE -DINSTANTIATE | FileCheck --check-prefix=CHECK-PROTOTYPE-INSTANTIATE %s
// RUN: %clang_cc1 %s -DREDEFINE -verify // RUN: %clang_cc1 %s -DREDEFINE -verify
// RUN: %clang_cc1 %s -DPROTOTYPE -DREDEFINE -verify // RUN: %clang_cc1 %s -DPROTOTYPE -DREDEFINE -verify
// PR8007: friend function not instantiated, reordered version. // PR8007: friend function not instantiated, reordered version.
// Corresponds to http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38392 // Corresponds to http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38392
// CHECK: define linkonce_odr{{.*}}_ZlsR11std_ostreamRK8StreamerI3FooE // CHECK: define linkonce_odr{{.*}}_ZlsR11std_ostreamRK8StreamerI3FooE
// CHECK-PROTOTYPE: define linkonce_odr{{.*}}_ZlsR11std_ostreamRK8StreamerI3FooE // CHECK-PROTOTYPE: define linkonce_odr{{.*}}_ZlsR11std_ostreamRK8StreamerI3FooE
// CHECK-INSTANTIATE: define linkonce_odr{{.*}}_ZlsR11std_ostreamRK8StreamerI3FooE // CHECK-INSTANTIATE: define linkonce_odr{{.*}}_ZlsR11std_ostreamRK8StreamerI3FooE
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

test/SemaTemplate/inject-templated-friend.cpp

// RUN: %clang_cc1 %s -emit-llvm -cxx-abi itanium -o - | FileCheck %s // RUN: %clang_cc1 %s -emit-llvm -triple %itanium_abi_triple -o - | FileCheck %s
// RUN: %clang_cc1 %s -DREDEFINE -verify // RUN: %clang_cc1 %s -DREDEFINE -verify
// PR8007: friend function not instantiated. // PR8007: friend function not instantiated.
// CHECK: define linkonce_odr{{.*}}_ZlsR11std_ostreamRK8StreamerI3FooE // CHECK: define linkonce_odr{{.*}}_ZlsR11std_ostreamRK8StreamerI3FooE
struct std_ostream struct std_ostream
{ {
int dummy; int dummy;
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/SemaTemplate/instantiate-complete.cpp

// RUN: %clang_cc1 -cxx-abi itanium -fsyntax-only -verify %s // RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -verify %s
// RUN: %clang_cc1 -cxx-abi microsoft -DMSABI -fsyntax-only -verify %s // RUN: %clang_cc1 -triple %ms_abi_triple -DMSABI -fsyntax-only -verify %s
// Tests various places where requiring a complete type involves // Tests various places where requiring a complete type involves
// instantiation of that type. // instantiation of that type.
template<typename T> template<typename T>
struct X { struct X {
X(T); X(T);
▲ Show 20 Lines • Show All 144 Lines • Show Last 20 Lines

test/SemaTemplate/instantiate-exception-spec-cxx11.cpp

// RUN: %clang_cc1 -fsyntax-only -verify -cxx-abi itanium -std=c++11 -ftemplate-depth 16 -fcxx-exceptions -fexceptions %s // RUN: %clang_cc1 -fsyntax-only -verify -triple %itanium_abi_triple -std=c++11 -ftemplate-depth 16 -fcxx-exceptions -fexceptions %s
// DR1330: an exception specification for a function template is only // DR1330: an exception specification for a function template is only
// instantiated when it is needed. // instantiated when it is needed.
// Note: the test is Itanium-specific because it depends on key functions in the // Note: the test is Itanium-specific because it depends on key functions in the
// PR12763 namespace. // PR12763 namespace.
template<typename T> void f1(T*) throw(T); // expected-error{{incomplete type 'Incomplete' is not allowed in exception specification}} template<typename T> void f1(T*) throw(T); // expected-error{{incomplete type 'Incomplete' is not allowed in exception specification}}
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

test/SemaTemplate/virtual-member-functions.cpp

// RUN: %clang_cc1 -cxx-abi itanium -fsyntax-only -verify %s // RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -verify %s
// RUN: %clang_cc1 -cxx-abi microsoft -DMSABI -fsyntax-only -verify %s // RUN: %clang_cc1 -triple %ms_abi_triple -DMSABI -fsyntax-only -verify %s
namespace PR5557 { namespace PR5557 {
template <class T> struct A { template <class T> struct A {
A(); A();
virtual void anchor(); virtual void anchor();
virtual int a(T x); virtual int a(T x);
}; };
template<class T> A<T>::A() {} template<class T> A<T>::A() {}
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

test/lit.cfg

Show First 20 Lines • Show All 222 Lines • ▼ Show 20 Lines if not cmd.stdout:
lit_config.fatal("Couldn't find the include dir for Clang ('%s')" % clang) lit_config.fatal("Couldn't find the include dir for Clang ('%s')" % clang)
dir = cmd.stdout.read().strip() dir = cmd.stdout.read().strip()
if sys.platform in ['win32'] and execute_external: if sys.platform in ['win32'] and execute_external:
# Don't pass dosish path separator to msys bash.exe. # Don't pass dosish path separator to msys bash.exe.
dir = dir.replace('\\', '/') dir = dir.replace('\\', '/')
# Ensure the result is an ascii string, across Python2.5+ - Python3. # Ensure the result is an ascii string, across Python2.5+ - Python3.
return str(dir.decode('ascii')) return str(dir.decode('ascii'))
def makeItaniumABITriple(triple):
m = re.match(r'(\w+)-(\w+)-(\w+)', triple)
if not m:
lit_config.fatal("Could not turn '%s' into Itanium ABI triple" % triple)
if m.group(3).lower() != 'win32':
# All non-win32 triples use the Itanium ABI.
return triple
return m.group(1) + '-' + m.group(2) + '-mingw32'
def makeMSABITriple(triple):
m = re.match(r'(\w+)-(\w+)-(\w+)', triple)
if not m:
lit_config.fatal("Could not turn '%s' into MS ABI triple" % triple)
if m.group(3).lower() == 'win32':
# If the OS is win32, we're done.
return triple
# Otherwise, replace the OS part with Win32.
return m.group(1) + '-' + m.group(2) + '-win32'
print makeItaniumABITriple(config.target_triple)
print makeMSABITriple(config.target_triple)
rnkUnsubmitted
Not Done
ReplyInline Actions

These debug prints should go away.

rnk: These debug prints should go away.
config.substitutions.append( ('%clang_cc1', '%s -cc1 -internal-isystem %s' config.substitutions.append( ('%clang_cc1', '%s -cc1 -internal-isystem %s'
% (config.clang, % (config.clang,
getClangBuiltinIncludeDir(config.clang))) ) getClangBuiltinIncludeDir(config.clang))) )
config.substitutions.append( ('%clang_cpp', ' ' + config.clang + config.substitutions.append( ('%clang_cpp', ' ' + config.clang +
' --driver-mode=cpp ')) ' --driver-mode=cpp '))
config.substitutions.append( ('%clang_cl', ' ' + config.clang + config.substitutions.append( ('%clang_cl', ' ' + config.clang +
' --driver-mode=cl ')) ' --driver-mode=cl '))
config.substitutions.append( ('%clangxx', ' ' + config.clang + config.substitutions.append( ('%clangxx', ' ' + config.clang +
' --driver-mode=g++ ')) ' --driver-mode=g++ '))
config.substitutions.append( ('%clang', ' ' + config.clang + ' ') ) config.substitutions.append( ('%clang', ' ' + config.clang + ' ') )
config.substitutions.append( ('%test_debuginfo', ' ' + config.llvm_src_root + '/utils/test_debuginfo.pl ') ) config.substitutions.append( ('%test_debuginfo', ' ' + config.llvm_src_root + '/utils/test_debuginfo.pl ') )
config.substitutions.append( ('%itanium_abi_triple', makeItaniumABITriple(config.target_triple)) )
config.substitutions.append( ('%ms_abi_triple', makeMSABITriple(config.target_triple)) )
# FIXME: Find nicer way to prohibit this. # FIXME: Find nicer way to prohibit this.
config.substitutions.append( config.substitutions.append(
(' clang ', """*** Do not use 'clang' in tests, use '%clang'. ***""") ) (' clang ', """*** Do not use 'clang' in tests, use '%clang'. ***""") )
config.substitutions.append( config.substitutions.append(
(' clang\+\+ ', """*** Do not use 'clang++' in tests, use '%clangxx'. ***""")) (' clang\+\+ ', """*** Do not use 'clang++' in tests, use '%clangxx'. ***"""))
config.substitutions.append( config.substitutions.append(
(' clang-cc ', (' clang-cc ',
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines