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 ↗(On Diff #6439)

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 ↗(On Diff #6439)

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
cfe/
trunk/
include/
clang/
Basic/
4 lines
Driver/
2 lines
lib/
Basic/
6 lines
6 lines
Driver/
4 lines
Frontend/
9 lines
1 line
Serialization/
2 lines
1 line
test/
CXX/
dcl.dcl/
dcl.link/
2 lines
dcl.spec/
dcl.constexpr/
2 lines
drs/
14 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
Modules/
1 line
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
21 lines

Diff 6449

cfe/trunk/include/clang/Basic/TargetOptions.h

Show All 32 Linespublic:
std::string CPU; std::string CPU;
/// If given, the unit to use for floating point math. /// If given, the unit to use for floating point math.
std::string FPMath; std::string FPMath;
/// If given, the name of the target ABI to use. /// If given, the name of the target ABI to use.
std::string ABI; std::string ABI;
/// If given, the name of the target C++ ABI to use. If not given, defaults
/// to "itanium".
std::string CXXABI;
/// If given, the version string of the linker in use. /// If given, the version string of the linker in use.
std::string LinkerVersion; std::string LinkerVersion;
/// \brief The list of target specific features to enable or disable, as written on the command line. /// \brief The list of target specific features to enable or disable, as written on the command line.
std::vector<std::string> FeaturesAsWritten; std::vector<std::string> FeaturesAsWritten;
/// The list of target specific features to enable or disable -- this should /// The list of target specific features to enable or disable -- this should
/// be a list of strings starting with by '+' or '-'. /// be a list of strings starting with by '+' or '-'.
std::vector<std::string> Features; std::vector<std::string> Features;
}; };
} // end namespace clang } // end namespace clang
#endif #endif

cfe/trunk/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

cfe/trunk/lib/Basic/TargetInfo.cpp

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 LinesTargetInfo::TargetInfo(const llvm::Triple &T) : TargetOpts(), Triple(T) {
HasAlignMac68kSupport = false; HasAlignMac68kSupport = false;
// Default to no types using fpret. // Default to no types using fpret.
RealTypeUsesObjCFPRet = 0; RealTypeUsesObjCFPRet = 0;
// Default to not using fp2ret for __Complex long double // Default to not using fp2ret for __Complex long double
ComplexLongDoubleUsesFP2Ret = false; ComplexLongDoubleUsesFP2Ret = false;
// Default to using the Itanium ABI. // Set the C++ ABI based on the triple.
TheCXXABI.set(TargetCXXABI::GenericItanium); TheCXXABI.set(Triple.getOS() == llvm::Triple::Win32
? TargetCXXABI::Microsoft
: TargetCXXABI::GenericItanium);
// Default to an empty address space map. // Default to an empty address space map.
AddrSpaceMap = &DefaultAddrSpaceMap; AddrSpaceMap = &DefaultAddrSpaceMap;
UseAddrSpaceMapMangling = false; UseAddrSpaceMapMangling = false;
// Default to an unknown platform name. // Default to an unknown platform name.
PlatformName = "unknown"; PlatformName = "unknown";
PlatformMinVersion = VersionTuple(); PlatformMinVersion = VersionTuple();
▲ Show 20 Lines • Show All 504 Lines • Show Last 20 Lines

cfe/trunk/lib/Basic/Targets.cpp

Show First 20 Lines • Show All 5,835 Lines • ▼ Show 20 LinesTargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
} }
// Set the target ABI if specified. // Set the target ABI if specified.
if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) { if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
Diags.Report(diag::err_target_unknown_abi) << Opts->ABI; Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
return 0; return 0;
} }
// Set the target C++ ABI.
if (!Opts->CXXABI.empty() && !Target->setCXXABI(Opts->CXXABI)) {
Diags.Report(diag::err_target_unknown_cxxabi) << Opts->CXXABI;
return 0;
}
// Set the fp math unit. // Set the fp math unit.
if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) { if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath; Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
return 0; return 0;
} }
// Compute the default target features, we need the target to handle this // Compute the default target features, we need the target to handle this
// because features may have dependencies on one another. // because features may have dependencies on one another.
Show All 25 Lines

cfe/trunk/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,927 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,252 Lines • Show Last 20 Lines

cfe/trunk/lib/Frontend/CompilerInvocation.cpp

Show First 20 Lines • Show All 1,611 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.
if (Opts.CXXABI.empty() &&
llvm::Triple(Opts.Triple).getOS() == llvm::Triple::Win32)
Opts.CXXABI = "microsoft";
} }
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 119 Lines • ▼ Show 20 Lines
#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
code = hash_combine(code, static_cast<unsigned>(LangOpts->get##Name())); code = hash_combine(code, static_cast<unsigned>(LangOpts->get##Name()));
#define BENIGN_LANGOPT(Name, Bits, Default, Description) #define BENIGN_LANGOPT(Name, Bits, Default, Description)
#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description) #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
#include "clang/Basic/LangOptions.def" #include "clang/Basic/LangOptions.def"
// Extend the signature with the target options. // Extend the signature with the target options.
code = hash_combine(code, TargetOpts->Triple, TargetOpts->CPU, code = hash_combine(code, TargetOpts->Triple, TargetOpts->CPU,
TargetOpts->ABI, TargetOpts->CXXABI, TargetOpts->ABI, TargetOpts->LinkerVersion);
TargetOpts->LinkerVersion);
for (unsigned i = 0, n = TargetOpts->FeaturesAsWritten.size(); i != n; ++i) for (unsigned i = 0, n = TargetOpts->FeaturesAsWritten.size(); i != n; ++i)
code = hash_combine(code, TargetOpts->FeaturesAsWritten[i]); code = hash_combine(code, TargetOpts->FeaturesAsWritten[i]);
// Extend the signature with preprocessor options. // Extend the signature with preprocessor options.
const PreprocessorOptions &ppOpts = getPreprocessorOpts(); const PreprocessorOptions &ppOpts = getPreprocessorOpts();
const HeaderSearchOptions &hsOpts = getHeaderSearchOpts(); const HeaderSearchOptions &hsOpts = getHeaderSearchOpts();
code = hash_combine(code, ppOpts.UsePredefines, ppOpts.DetailedRecord); code = hash_combine(code, ppOpts.UsePredefines, ppOpts.DetailedRecord);
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

cfe/trunk/lib/Frontend/FrontendActions.cpp

Show First 20 Lines • Show All 357 Lines • ▼ Show 20 Lines#include "clang/Basic/LangOptions.def"
} }
virtual bool ReadTargetOptions(const TargetOptions &TargetOpts, virtual bool ReadTargetOptions(const TargetOptions &TargetOpts,
bool Complain) { bool Complain) {
Out.indent(2) << "Target options:\n"; Out.indent(2) << "Target options:\n";
Out.indent(4) << " Triple: " << TargetOpts.Triple << "\n"; Out.indent(4) << " Triple: " << TargetOpts.Triple << "\n";
Out.indent(4) << " CPU: " << TargetOpts.CPU << "\n"; Out.indent(4) << " CPU: " << TargetOpts.CPU << "\n";
Out.indent(4) << " ABI: " << TargetOpts.ABI << "\n"; Out.indent(4) << " ABI: " << TargetOpts.ABI << "\n";
Out.indent(4) << " C++ ABI: " << TargetOpts.CXXABI << "\n";
Out.indent(4) << " Linker version: " << TargetOpts.LinkerVersion << "\n"; Out.indent(4) << " Linker version: " << TargetOpts.LinkerVersion << "\n";
if (!TargetOpts.FeaturesAsWritten.empty()) { if (!TargetOpts.FeaturesAsWritten.empty()) {
Out.indent(4) << "Target features:\n"; Out.indent(4) << "Target features:\n";
for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size(); for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size();
I != N; ++I) { I != N; ++I) {
Out.indent(6) << TargetOpts.FeaturesAsWritten[I] << "\n"; Out.indent(6) << TargetOpts.FeaturesAsWritten[I] << "\n";
} }
▲ Show 20 Lines • Show All 211 Lines • Show Last 20 Lines

cfe/trunk/lib/Serialization/ASTReader.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 134 Lines • ▼ Show 20 Lines if (Diags) \
Diags->Report(diag::err_pch_targetopt_mismatch) \ Diags->Report(diag::err_pch_targetopt_mismatch) \
<< Name << TargetOpts.Field << ExistingTargetOpts.Field; \ << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
return true; \ return true; \
} }
CHECK_TARGET_OPT(Triple, "target"); CHECK_TARGET_OPT(Triple, "target");
CHECK_TARGET_OPT(CPU, "target CPU"); CHECK_TARGET_OPT(CPU, "target CPU");
CHECK_TARGET_OPT(ABI, "target ABI"); CHECK_TARGET_OPT(ABI, "target ABI");
CHECK_TARGET_OPT(CXXABI, "target C++ ABI");
CHECK_TARGET_OPT(LinkerVersion, "target linker version"); CHECK_TARGET_OPT(LinkerVersion, "target linker version");
#undef CHECK_TARGET_OPT #undef CHECK_TARGET_OPT
// Compare feature sets. // Compare feature sets.
SmallVector<StringRef, 4> ExistingFeatures( SmallVector<StringRef, 4> ExistingFeatures(
ExistingTargetOpts.FeaturesAsWritten.begin(), ExistingTargetOpts.FeaturesAsWritten.begin(),
ExistingTargetOpts.FeaturesAsWritten.end()); ExistingTargetOpts.FeaturesAsWritten.end());
SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(), SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
▲ Show 20 Lines • Show All 3,852 Lines • ▼ Show 20 Lines
bool ASTReader::ParseTargetOptions(const RecordData &Record, bool ASTReader::ParseTargetOptions(const RecordData &Record,
bool Complain, bool Complain,
ASTReaderListener &Listener) { ASTReaderListener &Listener) {
unsigned Idx = 0; unsigned Idx = 0;
TargetOptions TargetOpts; TargetOptions TargetOpts;
TargetOpts.Triple = ReadString(Record, Idx); TargetOpts.Triple = ReadString(Record, Idx);
TargetOpts.CPU = ReadString(Record, Idx); TargetOpts.CPU = ReadString(Record, Idx);
TargetOpts.ABI = ReadString(Record, Idx); TargetOpts.ABI = ReadString(Record, Idx);
TargetOpts.CXXABI = ReadString(Record, Idx);
TargetOpts.LinkerVersion = ReadString(Record, Idx); TargetOpts.LinkerVersion = ReadString(Record, Idx);
for (unsigned N = Record[Idx++]; N; --N) { for (unsigned N = Record[Idx++]; N; --N) {
TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx)); TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
} }
for (unsigned N = Record[Idx++]; N; --N) { for (unsigned N = Record[Idx++]; N; --N) {
TargetOpts.Features.push_back(ReadString(Record, Idx)); TargetOpts.Features.push_back(ReadString(Record, Idx));
} }
▲ Show 20 Lines • Show All 3,623 Lines • Show Last 20 Lines

cfe/trunk/lib/Serialization/ASTWriter.cpp

Show First 20 Lines • Show All 1,097 Lines • ▼ Show 20 Lines#include "clang/Basic/Sanitizers.def"
// Target options. // Target options.
Record.clear(); Record.clear();
const TargetInfo &Target = Context.getTargetInfo(); const TargetInfo &Target = Context.getTargetInfo();
const TargetOptions &TargetOpts = Target.getTargetOpts(); const TargetOptions &TargetOpts = Target.getTargetOpts();
AddString(TargetOpts.Triple, Record); AddString(TargetOpts.Triple, Record);
AddString(TargetOpts.CPU, Record); AddString(TargetOpts.CPU, Record);
AddString(TargetOpts.ABI, Record); AddString(TargetOpts.ABI, Record);
AddString(TargetOpts.CXXABI, Record);
AddString(TargetOpts.LinkerVersion, Record); AddString(TargetOpts.LinkerVersion, Record);
Record.push_back(TargetOpts.FeaturesAsWritten.size()); Record.push_back(TargetOpts.FeaturesAsWritten.size());
for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size(); I != N; ++I) { for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size(); I != N; ++I) {
AddString(TargetOpts.FeaturesAsWritten[I], Record); AddString(TargetOpts.FeaturesAsWritten[I], Record);
} }
Record.push_back(TargetOpts.Features.size()); Record.push_back(TargetOpts.Features.size());
for (unsigned I = 0, N = TargetOpts.Features.size(); I != N; ++I) { for (unsigned I = 0, N = TargetOpts.Features.size(); I != N; ++I) {
AddString(TargetOpts.Features[I], Record); AddString(TargetOpts.Features[I], Record);
▲ Show 20 Lines • Show All 4,273 Lines • Show Last 20 Lines

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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());
}; };

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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() { }

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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();
} }

cfe/trunk/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
} }

cfe/trunk/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

cfe/trunk/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;
} }

cfe/trunk/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() {}
}; };

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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; }

cfe/trunk/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();
} }
}; };

cfe/trunk/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

cfe/trunk/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**

cfe/trunk/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_

cfe/trunk/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)

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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{{.*}} }

cfe/trunk/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

cfe/trunk/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]

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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;

cfe/trunk/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]{{$}}

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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() {}

cfe/trunk/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

cfe/trunk/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>();
} }
} }

cfe/trunk/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;
} }

cfe/trunk/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;
} }

cfe/trunk/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}}
} }

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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_

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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) { }

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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) {}

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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>) { }

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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 }

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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 }

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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"
} }

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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 327 Lines • Show Last 20 Lines

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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*
} }
} }

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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()

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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
} }

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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;
} }

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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
} }

cfe/trunk/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

cfe/trunk/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() {
} }

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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_

cfe/trunk/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_

cfe/trunk/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;

cfe/trunk/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();
} }

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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) { }

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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;
} }

cfe/trunk/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"

cfe/trunk/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 297 Lines • Show Last 20 Lines

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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 379 Lines • Show Last 20 Lines

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/test/Modules/module_file_info.m

Show All 10 Lines
// CHECK: C99: Yes // CHECK: C99: Yes
// CHECK: Objective-C 1: Yes // CHECK: Objective-C 1: Yes
// CHECK: modules extension to C: Yes // CHECK: modules extension to C: Yes
// CHECK: Target options: // CHECK: Target options:
// CHECK: Triple: // CHECK: Triple:
// CHECK: CPU: // CHECK: CPU:
// CHECK: ABI: // CHECK: ABI:
// CHECK: C++ ABI:
// CHECK: Linker version: // CHECK: Linker version:
// CHECK: Header search options: // CHECK: Header search options:
// CHECK: System root [-isysroot=]: '/' // CHECK: System root [-isysroot=]: '/'
// CHECK: Use builtin include directories [-nobuiltininc]: Yes // CHECK: Use builtin include directories [-nobuiltininc]: Yes
// CHECK: Use standard system include directories [-nostdinc]: Yes // CHECK: Use standard system include directories [-nostdinc]: Yes
// CHECK: Use standard C++ include directories [-nostdinc++]: Yes // CHECK: Use standard C++ include directories [-nostdinc++]: Yes
// CHECK: Use libc++ (rather than libstdc++) [-stdlib=]: // CHECK: Use libc++ (rather than libstdc++) [-stdlib=]:
// CHECK: Preprocessor options: // CHECK: Preprocessor options:
// CHECK: Uses compiler/target-specific predefines [-undef]: Yes // CHECK: Uses compiler/target-specific predefines [-undef]: Yes
// CHECK: Uses detailed preprocessing record (for indexing): No // CHECK: Uses detailed preprocessing record (for indexing): No
// CHECK: Predefined macros: // CHECK: Predefined macros:
// CHECK: -DBLARG // CHECK: -DBLARG
// CHECK: -DWIBBLE=WOBBLE // CHECK: -DWIBBLE=WOBBLE

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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]

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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}}

cfe/trunk/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

cfe/trunk/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];

cfe/trunk/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&);
} }

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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'
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