From 1a711b169619e1109cb9affed650f8f12ae85f6e Mon Sep 17 00:00:00 2001 From: Reid Kleckner Date: Tue, 22 Jul 2014 00:53:05 +0000 Subject: [PATCH] -fms-extensions: Implement half of #pragma init_seg Summary: This pragma is very rare. We could *hypothetically* lower some uses of it down to @llvm.global_ctors, but given that GlobalOpt isn't able to optimize prioritized global ctors today, there's really no point. If we wanted to do this in the future, I would check if the section used in the pragma started with ".CRT$XC" and had up to two characters after it. Those two characters could form the 16-bit initialization priority that we support in @llvm.global_ctors. We would have to teach LLVM to lower prioritized global ctors on COFF as well. This should let us compile some silly uses of this pragma in WebKit / Blink. Reviewers: rsmith, majnemer Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4549 llvm-svn: 213593 --- clang/include/clang/Basic/Attr.td | 12 +++ clang/include/clang/Basic/AttrDocs.td | 16 ++++ .../clang/Basic/DiagnosticParseKinds.td | 3 + clang/include/clang/Parse/Parser.h | 2 +- clang/include/clang/Sema/Sema.h | 8 ++ clang/lib/CodeGen/CGDeclCXX.cpp | 33 +++++++- clang/lib/CodeGen/CodeGenModule.h | 3 + clang/lib/Parse/ParsePragma.cpp | 57 ++++++++++++- clang/lib/Parse/Parser.cpp | 2 +- clang/lib/Sema/Sema.cpp | 2 +- clang/lib/Sema/SemaAttr.cpp | 9 ++ clang/lib/Sema/SemaDecl.cpp | 7 ++ clang/test/CodeGenCXX/pragma-init_seg.cpp | 82 ++++++++++++++++--- clang/test/SemaCXX/pragma-init_seg.cpp | 15 ++++ 14 files changed, 229 insertions(+), 22 deletions(-) create mode 100644 clang/test/SemaCXX/pragma-init_seg.cpp diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td index 62bb1ddb7f39..704a375ba291 100644 --- a/clang/include/clang/Basic/Attr.td +++ b/clang/include/clang/Basic/Attr.td @@ -1767,6 +1767,18 @@ def MSVtorDisp : InheritableAttr { let Documentation = [Undocumented]; } +def InitSeg : Attr { + let Spellings = [Pragma<"", "init_seg">]; + let Args = [StringArgument<"Section">]; + let SemaHandler = 0; + let Documentation = [InitSegDocs]; + let AdditionalMembers = [{ + void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const { + OS << '(' << getSection() << ')'; + } + }]; +} + def Unaligned : IgnoredAttr { let Spellings = [Keyword<"__unaligned">]; } diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td index 97002320277d..e6d6a33d3b5d 100644 --- a/clang/include/clang/Basic/AttrDocs.td +++ b/clang/include/clang/Basic/AttrDocs.td @@ -36,6 +36,22 @@ global variable or function should be in after translation. let Heading = "section (gnu::section, __declspec(allocate))"; } +def InitSegDocs : Documentation { + let Category = DocCatVariable; + let Content = [{ +The attribute applied by ``pragma init_seg()`` controls the section into +which global initialization function pointers are emitted. It is only +available with ``-fms-extensions``. Typically, this function pointer is +emitted into ``.CRT$XCU`` on Windows. The user can change the order of +initialization by using a different section name with the same +``.CRT$XC`` prefix and a suffix that sorts lexicographically before or +after the standard ``.CRT$XCU`` sections. See the init_seg_ +documentation on MSDN for more information. + +.. _init_seg: http://msdn.microsoft.com/en-us/library/7977wcck(v=vs.110).aspx + }]; +} + def TLSModelDocs : Documentation { let Category = DocCatVariable; let Content = [{ diff --git a/clang/include/clang/Basic/DiagnosticParseKinds.td b/clang/include/clang/Basic/DiagnosticParseKinds.td index af0baebc1319..35ed795c9fd7 100644 --- a/clang/include/clang/Basic/DiagnosticParseKinds.td +++ b/clang/include/clang/Basic/DiagnosticParseKinds.td @@ -800,6 +800,9 @@ def warn_pragma_expected_section_push_pop_or_name : Warning< def warn_pragma_expected_section_label_or_name : Warning< "expected a stack label or a string literal for the section name in '#pragma %0' - ignored">, InGroup; +def warn_pragma_expected_init_seg : Warning< + "expected 'compiler', 'lib', 'user', or a string literal for the section name in '#pragma %0' - ignored">, + InGroup; def warn_pragma_expected_integer : Warning< "expected integer between %0 and %1 inclusive in '#pragma %2' - ignored">, InGroup; diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h index 73bef66c2ce6..c58c41a44c58 100644 --- a/clang/include/clang/Parse/Parser.h +++ b/clang/include/clang/Parse/Parser.h @@ -725,7 +725,7 @@ private: /// returned. bool ExpectAndConsume(tok::TokenKind ExpectedTok, unsigned Diag = diag::err_expected, - const char *DiagMsg = ""); + StringRef DiagMsg = ""); /// \brief The parser expects a semicolon and, if present, will consume it. /// diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index 43fa508ad407..83488d0a6a61 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -330,6 +330,10 @@ public: PragmaStack ConstSegStack; PragmaStack CodeSegStack; + /// Last section used with #pragma init_seg. + StringLiteral *CurInitSeg; + SourceLocation CurInitSegLoc; + /// VisContext - Manages the stack for \#pragma GCC visibility. void *VisContext; // Really a "PragmaVisStack*" @@ -7179,6 +7183,10 @@ public: void ActOnPragmaMSSection(SourceLocation PragmaLocation, int SectionFlags, StringLiteral *SegmentName); + /// \brief Called on well-formed \#pragma init_seg(). + void ActOnPragmaMSInitSeg(SourceLocation PragmaLocation, + StringLiteral *SegmentName); + /// ActOnPragmaDetectMismatch - Call on well-formed \#pragma detect_mismatch void ActOnPragmaDetectMismatch(StringRef Name, StringRef Value); diff --git a/clang/lib/CodeGen/CGDeclCXX.cpp b/clang/lib/CodeGen/CGDeclCXX.cpp index 6a03e9afe4d1..94cfe211601f 100644 --- a/clang/lib/CodeGen/CGDeclCXX.cpp +++ b/clang/lib/CodeGen/CGDeclCXX.cpp @@ -257,6 +257,32 @@ CreateGlobalInitOrDestructFunction(CodeGenModule &CGM, return Fn; } +/// Create a global pointer to a function that will initialize a global +/// variable. The user has requested that this pointer be emitted in a specific +/// section. +void CodeGenModule::EmitPointerToInitFunc(const VarDecl *D, + llvm::GlobalVariable *GV, + llvm::Function *InitFunc, + InitSegAttr *ISA) { + llvm::GlobalVariable *PtrArray = new llvm::GlobalVariable( + TheModule, InitFunc->getType(), /*isConstant=*/true, + llvm::GlobalValue::PrivateLinkage, InitFunc, "__cxx_init_fn_ptr"); + PtrArray->setSection(ISA->getSection()); + addUsedGlobal(PtrArray); + + // If the GV is already in a comdat group, then we have to join it. + llvm::Comdat *C = GV->getComdat(); + + // LinkOnce and Weak linkage are lowered down to a single-member comdat group. + // Make an explicit group so we can join it. + if (!C && (GV->hasWeakLinkage() || GV->hasLinkOnceLinkage())) { + C = TheModule.getOrInsertComdat(GV->getName()); + GV->setComdat(C); + } + if (C) + PtrArray->setComdat(C); +} + void CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D, llvm::GlobalVariable *Addr, @@ -272,9 +298,9 @@ CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D, llvm::Function *Fn = CreateGlobalInitOrDestructFunction(*this, FTy, FnName.str()); + auto *ISA = D->getAttr(); CodeGenFunction(*this).GenerateCXXGlobalVarDeclInitFunc(Fn, D, Addr, PerformInit); - if (D->getTLSKind()) { // FIXME: Should we support init_priority for thread_local? // FIXME: Ideally, initialization of instantiated thread_local static data @@ -283,7 +309,10 @@ CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D, // FIXME: We only need to register one __cxa_thread_atexit function for the // entire TU. CXXThreadLocalInits.push_back(Fn); - } else if (const InitPriorityAttr *IPA = D->getAttr()) { + } else if (PerformInit && ISA) { + EmitPointerToInitFunc(D, Addr, Fn, ISA); + DelayedCXXInitPosition.erase(D); + } else if (auto *IPA = D->getAttr()) { OrderGlobalInits Key(IPA->getPriority(), PrioritizedCXXGlobalInits.size()); PrioritizedCXXGlobalInits.push_back(std::make_pair(Key, Fn)); DelayedCXXInitPosition.erase(D); diff --git a/clang/lib/CodeGen/CodeGenModule.h b/clang/lib/CodeGen/CodeGenModule.h index c65598e96df0..44597bfaa917 100644 --- a/clang/lib/CodeGen/CodeGenModule.h +++ b/clang/lib/CodeGen/CodeGenModule.h @@ -1103,6 +1103,9 @@ private: llvm::GlobalVariable *Addr, bool PerformInit); + void EmitPointerToInitFunc(const VarDecl *VD, llvm::GlobalVariable *Addr, + llvm::Function *InitFunc, InitSegAttr *ISA); + // FIXME: Hardcoding priority here is gross. void AddGlobalCtor(llvm::Function *Ctor, int Priority = 65535, llvm::Constant *AssociatedData = 0); diff --git a/clang/lib/Parse/ParsePragma.cpp b/clang/lib/Parse/ParsePragma.cpp index a7b5f6ebddb3..b94c4bc9448a 100644 --- a/clang/lib/Parse/ParsePragma.cpp +++ b/clang/lib/Parse/ParsePragma.cpp @@ -652,12 +652,61 @@ bool Parser::HandlePragmaMSSegment(StringRef PragmaName, return true; } +// #pragma init_seg({ compiler | lib | user | "section-name" [, func-name]} ) bool Parser::HandlePragmaMSInitSeg(StringRef PragmaName, SourceLocation PragmaLocation) { - PP.Diag(PragmaLocation, - PP.getDiagnostics().getCustomDiagID( - DiagnosticsEngine::Error, "'#pragma init_seg' not implemented.")); - return false; + if (ExpectAndConsume(tok::l_paren, diag::warn_pragma_expected_lparen, + PragmaName)) + return false; + + // Parse either the known section names or the string section name. + StringLiteral *SegmentName = nullptr; + if (Tok.isAnyIdentifier()) { + auto *II = Tok.getIdentifierInfo(); + StringRef Section = llvm::StringSwitch(II->getName()) + .Case("compiler", "\".CRT$XCC\"") + .Case("lib", "\".CRT$XCL\"") + .Case("user", "\".CRT$XCU\"") + .Default(""); + + if (!Section.empty()) { + // Pretend the user wrote the appropriate string literal here. + Token Toks[1]; + Toks[0].startToken(); + Toks[0].setKind(tok::string_literal); + Toks[0].setLocation(Tok.getLocation()); + Toks[0].setLiteralData(Section.data()); + Toks[0].setLength(Section.size()); + SegmentName = + cast(Actions.ActOnStringLiteral(Toks, nullptr).get()); + PP.Lex(Tok); + } + } else if (Tok.is(tok::string_literal)) { + ExprResult StringResult = ParseStringLiteralExpression(); + if (StringResult.isInvalid()) + return false; + SegmentName = cast(StringResult.get()); + if (SegmentName->getCharByteWidth() != 1) { + PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string) + << PragmaName; + return false; + } + // FIXME: Add support for the '[, func-name]' part of the pragma. + } + + if (!SegmentName) { + PP.Diag(PragmaLocation, diag::warn_pragma_expected_init_seg) << PragmaName; + return false; + } + + if (ExpectAndConsume(tok::r_paren, diag::warn_pragma_expected_rparen, + PragmaName) || + ExpectAndConsume(tok::eof, diag::warn_pragma_extra_tokens_at_eol, + PragmaName)) + return false; + + Actions.ActOnPragmaMSInitSeg(PragmaLocation, SegmentName); + return true; } struct PragmaLoopHintInfo { diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp index d28e046cfccd..37ce157e0812 100644 --- a/clang/lib/Parse/Parser.cpp +++ b/clang/lib/Parse/Parser.cpp @@ -109,7 +109,7 @@ static bool IsCommonTypo(tok::TokenKind ExpectedTok, const Token &Tok) { } bool Parser::ExpectAndConsume(tok::TokenKind ExpectedTok, unsigned DiagID, - const char *Msg) { + StringRef Msg) { if (Tok.is(ExpectedTok) || Tok.is(tok::code_completion)) { ConsumeAnyToken(); return false; diff --git a/clang/lib/Sema/Sema.cpp b/clang/lib/Sema/Sema.cpp index 478c34f047d7..2c653325b37b 100644 --- a/clang/lib/Sema/Sema.cpp +++ b/clang/lib/Sema/Sema.cpp @@ -87,7 +87,7 @@ Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, LangOpts.getMSPointerToMemberRepresentationMethod()), VtorDispModeStack(1, MSVtorDispAttr::Mode(LangOpts.VtorDispMode)), DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr), - CodeSegStack(nullptr), VisContext(nullptr), + CodeSegStack(nullptr), CurInitSeg(nullptr), VisContext(nullptr), IsBuildingRecoveryCallExpr(false), ExprNeedsCleanups(false), LateTemplateParser(nullptr), OpaqueParser(nullptr), IdResolver(pp), StdInitializerList(nullptr), diff --git a/clang/lib/Sema/SemaAttr.cpp b/clang/lib/Sema/SemaAttr.cpp index 7c182a1c6489..a7d606d545ca 100644 --- a/clang/lib/Sema/SemaAttr.cpp +++ b/clang/lib/Sema/SemaAttr.cpp @@ -431,6 +431,15 @@ void Sema::ActOnPragmaMSSection(SourceLocation PragmaLocation, UnifySection(SegmentName->getString(), SectionFlags, PragmaLocation); } +void Sema::ActOnPragmaMSInitSeg(SourceLocation PragmaLocation, + StringLiteral *SegmentName) { + // There's no stack to maintain, so we just have a current section. When we + // see the default section, reset our current section back to null so we stop + // tacking on unnecessary attributes. + CurInitSeg = SegmentName->getString() == ".CRT$XCU" ? nullptr : SegmentName; + CurInitSegLoc = PragmaLocation; +} + void Sema::ActOnPragmaUnused(const Token &IdTok, Scope *curScope, SourceLocation PragmaLoc) { diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index 3e930f4735c2..bbe69306b645 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -9125,6 +9125,13 @@ void Sema::CheckCompleteVariableDeclaration(VarDecl *var) { if (const SectionAttr *SA = var->getAttr()) if (UnifySection(SA->getName(), SectionFlags, var)) var->dropAttr(); + + // Apply the init_seg attribute if this has an initializer. If the + // initializer turns out to not be dynamic, we'll end up ignoring this + // attribute. + if (CurInitSeg && var->getInit()) + var->addAttr(InitSegAttr::CreateImplicit(Context, CurInitSeg->getString(), + CurInitSegLoc)); } // All the following checks are C++ only. diff --git a/clang/test/CodeGenCXX/pragma-init_seg.cpp b/clang/test/CodeGenCXX/pragma-init_seg.cpp index 7356c52aa395..3f9ff217e6b6 100644 --- a/clang/test/CodeGenCXX/pragma-init_seg.cpp +++ b/clang/test/CodeGenCXX/pragma-init_seg.cpp @@ -1,16 +1,72 @@ -// RUN: not %clang_cc1 %s -triple=i686-pc-win32 -fms-extensions -emit-llvm-only 2>&1 | FileCheck %s +// RUN: %clang_cc1 %s -triple=i686-pc-win32 -fms-extensions -emit-llvm -o - | FileCheck %s -// Reduced from WebKit. +int f(); -// FIXME: Implement this pragma and test the codegen. We probably want to -// completely skip @llvm.global_ctors and just create global function pointers -// to the initializer with the right section. +// CHECK: $"\01?x@selectany_init@@3HA" = comdat any +// CHECK: $"\01?x@?$A@H@explicit_template_instantiation@@2HB" = comdat any +// CHECK: $"\01?x@?$A@H@implicit_template_instantiation@@2HB" = comdat any -// CHECK: '#pragma init_seg' not implemented -#pragma init_seg(".unwantedstaticinits") -struct A { - A(); - ~A(); - int a; -}; -A a; +namespace simple_init { +#pragma init_seg(compiler) +int x = f(); +// CHECK: @"\01?x@simple_init@@3HA" = global i32 0, align 4 +// CHECK: @__cxx_init_fn_ptr = private constant void ()* @"\01??__Ex@simple_init@@YAXXZ", section ".CRT$XCC" + +#pragma init_seg(lib) +int y = f(); +// CHECK: @"\01?y@simple_init@@3HA" = global i32 0, align 4 +// CHECK: @__cxx_init_fn_ptr1 = private constant void ()* @"\01??__Ey@simple_init@@YAXXZ", section ".CRT$XCL" + +#pragma init_seg(user) +int z = f(); +// CHECK: @"\01?z@simple_init@@3HA" = global i32 0, align 4 +// No function pointer! This one goes on @llvm.global_ctors. +} + +#pragma init_seg(".asdf") + +namespace internal_init { +namespace { +int x = f(); +// CHECK: @"\01?x@?A@internal_init@@3HA" = internal global i32 0, align 4 +// CHECK: @__cxx_init_fn_ptr2 = private constant void ()* @"\01??__Ex@?A@internal_init@@YAXXZ", section ".asdf" +} +} + +namespace selectany_init { +int __declspec(selectany) x = f(); +// CHECK: @"\01?x@selectany_init@@3HA" = weak_odr global i32 0, comdat $"\01?x@selectany_init@@3HA", align 4 +// CHECK: @__cxx_init_fn_ptr3 = private constant void ()* @"\01??__Ex@selectany_init@@YAXXZ", section ".asdf", comdat $"\01?x@selectany_init@@3HA" +} + +namespace explicit_template_instantiation { +template struct A { static const int x; }; +template const int A::x = f(); +template struct A; +// CHECK: @"\01?x@?$A@H@explicit_template_instantiation@@2HB" = weak_odr global i32 0, comdat $"\01?x@?$A@H@explicit_template_instantiation@@2HB", align 4 +// CHECK: @__cxx_init_fn_ptr4 = private constant void ()* @"\01??__Ex@?$A@H@explicit_template_instantiation@@2HB@YAXXZ", section ".asdf", comdat $"\01?x@?$A@H@explicit_template_instantiation@@2HB" +} + +namespace implicit_template_instantiation { +template struct A { static const int x; }; +template const int A::x = f(); +int g() { return A::x; } +// CHECK: @"\01?x@?$A@H@implicit_template_instantiation@@2HB" = linkonce_odr global i32 0, comdat $"\01?x@?$A@H@implicit_template_instantiation@@2HB", align 4 +// CHECK: @__cxx_init_fn_ptr5 = private constant void ()* @"\01??__Ex@?$A@H@implicit_template_instantiation@@2HB@YAXXZ", section ".asdf", comdat $"\01?x@?$A@H@implicit_template_instantiation@@2HB" +} + +// ... and here's where we emitted user level ctors. +// CHECK: @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] +// CHECK: [{ i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_pragma_init_seg.cpp, i8* null }] + +// We have to mark everything used so we can survive globalopt, even through +// LTO. There's no way LLVM could really understand if data in the .asdf +// section is really used or dead. +// +// CHECK: @llvm.used = appending global [6 x i8*] +// CHECK: [i8* bitcast (void ()** @__cxx_init_fn_ptr to i8*), +// CHECK: i8* bitcast (void ()** @__cxx_init_fn_ptr1 to i8*), +// CHECK: i8* bitcast (void ()** @__cxx_init_fn_ptr2 to i8*), +// CHECK: i8* bitcast (void ()** @__cxx_init_fn_ptr3 to i8*), +// CHECK: i8* bitcast (void ()** @__cxx_init_fn_ptr4 to i8*), +// CHECK: i8* bitcast (void ()** @__cxx_init_fn_ptr5 to i8*)], section "llvm.metadata" diff --git a/clang/test/SemaCXX/pragma-init_seg.cpp b/clang/test/SemaCXX/pragma-init_seg.cpp new file mode 100644 index 000000000000..38520b0c2eff --- /dev/null +++ b/clang/test/SemaCXX/pragma-init_seg.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -fms-extensions %s -triple x86_64-pc-win32 + +#pragma init_seg(L".my_seg") // expected-warning {{expected 'compiler', 'lib', 'user', or a string literal}} +#pragma init_seg( // expected-warning {{expected 'compiler', 'lib', 'user', or a string literal}} +#pragma init_seg asdf // expected-warning {{missing '('}} +#pragma init_seg) // expected-warning {{missing '('}} +#pragma init_seg("a" "b") // no warning +#pragma init_seg("a", "b") // expected-warning {{missing ')'}} +#pragma init_seg("a") asdf // expected-warning {{extra tokens at end of '#pragma init_seg'}} +#pragma init_seg("\x") // expected-error {{\x used with no following hex digits}} +#pragma init_seg("a" L"b") // expected-warning {{expected non-wide string literal in '#pragma init_seg'}} + +int f(); +#pragma init_seg(compiler) +int __declspec(thread) x = f(); // expected-error {{initializer for thread-local variable must be a constant expression}}