From d4fca284bd20fe46b3b3882543eda5164243667d Mon Sep 17 00:00:00 2001 From: weixin_93 Date: Tue, 29 Aug 2023 16:54:19 +0800 Subject: [PATCH 1/5] add cfunction_like_macro --- clang/include/clang/Basic/Attr.td | 5 +++++ clang/lib/Sema/SemaDeclAttr.cpp | 7 +++++++ 2 files changed, 12 insertions(+) diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td index a0a87b0fe161..836e13cbb218 100644 --- a/clang/include/clang/Basic/Attr.td +++ b/clang/include/clang/Basic/Attr.td @@ -4127,3 +4127,8 @@ def ReturnsByteCountIndex : InheritableAttr { let InheritEvenIfAlreadyPresent = 1; let TemplateDependent = 1; } +def FunctionLikeMacro : InheritableAttr { + let Spellings = [GNU<"function_like_macro">]; + let Subjects = SubjectList<[Function]>; + let Documentation = [Undocumented]; +} \ No newline at end of file diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp index cabbe67a1cbd..12cdf4f6e0fc 100644 --- a/clang/lib/Sema/SemaDeclAttr.cpp +++ b/clang/lib/Sema/SemaDeclAttr.cpp @@ -8679,6 +8679,10 @@ static void handleReturnsCountIndexFuncPtr(Sema &S, Decl *D, const ParsedAttr &A D->addAttr(::new (S.Context) ReturnsCountIndexAttr(S.Context, AL, LenVarIdx)); } +static void handleFunctionLikeMacro(Sema &S, Decl *D, const ParsedAttr &Attrs) { + D->addAttr(::new (S.Context) FunctionLikeMacroAttr(S.Context, Attrs)); +} + //===----------------------------------------------------------------------===// // Top Level Sema Entry Points //===----------------------------------------------------------------------===// @@ -9538,6 +9542,9 @@ ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, const ParsedAttr &AL, else handleReturnsCountIndexAttr(S, D, AL, true); break; + case ParsedAttr::AT_FunctionLikeMacro: + handleFunctionLikeMacro(S, D, AL); + break; } } -- Gitee From d990fc1aab8a61cf4d490d340caa7fe2daa7aa3f Mon Sep 17 00:00:00 2001 From: weixin_93 Date: Tue, 29 Aug 2023 19:16:21 +0800 Subject: [PATCH 2/5] add pragma_prefer_inline --- clang/include/clang/AST/Expr.h | 9 +++ clang/include/clang/AST/Stmt.h | 5 +- .../clang/Basic/DiagnosticParseKinds.td | 6 +- clang/include/clang/Basic/Specifiers.h | 6 ++ clang/include/clang/Basic/TokenKinds.def | 5 ++ clang/include/clang/Parse/Parser.h | 7 +++ clang/include/clang/Sema/Sema.h | 16 +++++ clang/lib/AST/Expr.cpp | 2 + clang/lib/AST/TextNodeDumper.cpp | 7 +++ clang/lib/Parse/ParsePragma.cpp | 60 +++++++++++++++++++ clang/lib/Parse/ParseStmt.cpp | 30 ++++++++++ clang/lib/Sema/SemaExpr.cpp | 7 +++ clang/lib/Sema/SemaStmt.cpp | 10 ++++ clang/lib/Serialization/ASTReaderStmt.cpp | 3 + clang/lib/Serialization/ASTWriterStmt.cpp | 3 + 15 files changed, 173 insertions(+), 3 deletions(-) diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h index aa582da91605..35fcf6078f75 100644 --- a/clang/include/clang/AST/Expr.h +++ b/clang/include/clang/AST/Expr.h @@ -2867,6 +2867,15 @@ public: static constexpr ADLCallKind NotADL = ADLCallKind::NotADL; static constexpr ADLCallKind UsesADL = ADLCallKind::UsesADL; +#ifdef LLVM_BISHENGCLANGUAGE + void setPreferInlineScopeSpecifier(PreferInlineScopeSpecifier PreferInlineSpec) { + CallExprBits.PreferInlineSpecifier = PreferInlineSpec; + } + + PreferInlineScopeSpecifier getPreferInlineScopeSpecifier() const { + return (PreferInlineScopeSpecifier) CallExprBits.PreferInlineSpecifier; + } +#endif protected: /// Build a call expression, assuming that appropriate storage has been /// allocated for the trailing objects. diff --git a/clang/include/clang/AST/Stmt.h b/clang/include/clang/AST/Stmt.h index 87a4951ebf9c..43a662dc879e 100644 --- a/clang/include/clang/AST/Stmt.h +++ b/clang/include/clang/AST/Stmt.h @@ -470,9 +470,10 @@ protected: /// True if the call expression has some floating-point features. unsigned HasFPFeatures : 1; - /// Padding used to align OffsetToTrailingObjects to a byte multiple. - unsigned : 24 - 3 - NumExprBits; + uint64_t PreferInlineSpecifier : 2; + /// Padding used to align OffsetToTrailingObjects to a byte multiple. + unsigned : 24 - 5 - NumExprBits; /// The offset in bytes from the this pointer to the start of the /// trailing objects belonging to CallExpr. Intentionally byte sized /// for faster access. diff --git a/clang/include/clang/Basic/DiagnosticParseKinds.td b/clang/include/clang/Basic/DiagnosticParseKinds.td index a204e13351f8..5c64e855dad9 100644 --- a/clang/include/clang/Basic/DiagnosticParseKinds.td +++ b/clang/include/clang/Basic/DiagnosticParseKinds.td @@ -1609,7 +1609,11 @@ def err_unknown_hlsl_semantic : Error<"unknown HLSL semantic %0">; def ext_hlsl_access_specifiers : ExtWarn< "access specifiers are a clang HLSL extension">, InGroup; - + +def warn_pragma_prefer_inline : Warning< + "incorrect use of '#pragma prefer_inline on|off' - ignored">, + InGroup; + // BSC Parser Diagnostics def invalid_param_for_trait_member : Error<"the first parameter of trait member function must be 'This* this'">; def err_unexpected_token_for_impl_trait_decl : Error<"unexpected token for ImplTraitDecl">; diff --git a/clang/include/clang/Basic/Specifiers.h b/clang/include/clang/Basic/Specifiers.h index b21e8c8a3e39..76fe2f7deacb 100644 --- a/clang/include/clang/Basic/Specifiers.h +++ b/clang/include/clang/Basic/Specifiers.h @@ -398,6 +398,12 @@ namespace clang { SS_Safe = 1, SS_Unsafe = 2, }; + + enum PreferInlineScopeSpecifier { + PI_None = 0, + PI_PreferInline = 1, + PI_PreferNoInline = 2, + }; } // end namespace clang #endif // LLVM_CLANG_BASIC_SPECIFIERS_H diff --git a/clang/include/clang/Basic/TokenKinds.def b/clang/include/clang/Basic/TokenKinds.def index 2dfe2c44eb98..3a5b123482a2 100644 --- a/clang/include/clang/Basic/TokenKinds.def +++ b/clang/include/clang/Basic/TokenKinds.def @@ -810,6 +810,11 @@ PRAGMA_ANNOTATION(pragma_unused) // handles #pragma SAFE ... directives. PRAGMA_ANNOTATION(pragma_safe) +// Annotations for pragma prefer_inline (ON/OFF) +// The lexer produces these so that they only take effect when the parser +// handles #pragma prefer_inline ... directives. +PRAGMA_ANNOTATION(pragma_prefer_inline) + // Annotation for #pragma GCC visibility... // The lexer produces these so that they only take effect when the parser // handles them. diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h index 57c80ec6c275..b0ca13127dcd 100644 --- a/clang/include/clang/Parse/Parser.h +++ b/clang/include/clang/Parse/Parser.h @@ -217,6 +217,7 @@ class Parser : public CodeCompletionHandler { std::unique_ptr MaxTokensTotalPragmaHandler; std::unique_ptr RISCVPragmaHandler; std::unique_ptr SafeHandler; + std::unique_ptr PreferInlineHandler; std::unique_ptr CommentSemaHandler; @@ -296,6 +297,11 @@ class Parser : public CodeCompletionHandler { } void DestroyTemplateIds(); + /// Reset "#pragma prefer_inline ON/OFF" + void ResetPreferInlineScopeToNone() { + Actions.SetPragmaPreferInlineInfo(PI_None); + } + /// RAII object to destroy TemplateIdAnnotations where possible, from a /// likely-good position during parsing. struct DestroyTemplateIdAnnotationsRAIIObj { @@ -792,6 +798,7 @@ private: void HandlePragmaAttribute(); void HandlePragmaSafe(); + void HandlePragmaPreferInline(); /// GetLookAheadToken - This peeks ahead N tokens and returns that token /// without consuming any tokens. LookAhead(0) returns 'Tok', LookAhead(1) diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index 7904559b25d9..b779c16fc4dd 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -4921,6 +4921,7 @@ public: private: SafeScopeSpecifier PragmaSafeInfo = SS_None; + PreferInlineScopeSpecifier PragmaPreferInlineInfo = PI_None; public: enum PragmaSafeStatus { @@ -4938,6 +4939,21 @@ public: PragmaSafeInfo = SafeSpec; } + + enum PragmaPreferInlineStatus { + PPI_On, + PPI_Off, + }; + + void ActOnPragmaPreferInline(PragmaPreferInlineStatus St); + + PreferInlineScopeSpecifier GetPragmaPreferInlineInfo() { + return PragmaPreferInlineInfo; + } + + void SetPragmaPreferInlineInfo(PreferInlineScopeSpecifier PreferInlineSpec) { + PragmaPreferInlineInfo = PreferInlineSpec; + } /// A RAII object to enter scope of a compound statement. class CompoundScopeRAII { public: diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp index f4be484bc0a9..149acc6f5d13 100644 --- a/clang/lib/AST/Expr.cpp +++ b/clang/lib/AST/Expr.cpp @@ -1379,6 +1379,8 @@ CallExpr::CallExpr(StmtClass SC, Expr *Fn, ArrayRef PreArgs, CallExprBits.HasFPFeatures = FPFeatures.requiresTrailingStorage(); if (hasStoredFPFeatures()) setStoredFPFeatures(FPFeatures); + + CallExprBits.PreferInlineSpecifier = PI_None; } CallExpr::CallExpr(StmtClass SC, unsigned NumPreArgs, unsigned NumArgs, diff --git a/clang/lib/AST/TextNodeDumper.cpp b/clang/lib/AST/TextNodeDumper.cpp index 0796d55b81e7..7752d97bbf02 100644 --- a/clang/lib/AST/TextNodeDumper.cpp +++ b/clang/lib/AST/TextNodeDumper.cpp @@ -1004,6 +1004,13 @@ void TextNodeDumper::VisitCallExpr(const CallExpr *Node) { OS << " adl"; if (Node->hasStoredFPFeatures()) printFPOptions(Node->getFPFeatures()); +#ifdef LLVM_BISHENGCLANGUAGE + if (Node->getPreferInlineScopeSpecifier() == PI_PreferInline) { + OS << " prefer_inline"; + } else if (Node->getPreferInlineScopeSpecifier() == PI_PreferNoInline) { + OS << " prefer_no_inline"; + } +#endif } void TextNodeDumper::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *Node) { diff --git a/clang/lib/Parse/ParsePragma.cpp b/clang/lib/Parse/ParsePragma.cpp index 7a1c87d30be4..6df31ee9b714 100644 --- a/clang/lib/Parse/ParsePragma.cpp +++ b/clang/lib/Parse/ParsePragma.cpp @@ -344,6 +344,12 @@ struct PragmaSafeHandler : public PragmaHandler { Token &FirstToken) override; }; +struct PragmaPreferInlineHandler : public PragmaHandler { + PragmaPreferInlineHandler() : PragmaHandler("prefer_inline") {} + void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, + Token &FirstToken) override; +}; + struct PragmaMaxTokensHereHandler : public PragmaHandler { PragmaMaxTokensHereHandler() : PragmaHandler("max_tokens_here") {} void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, @@ -517,6 +523,9 @@ void Parser::initializePragmaHandlers() { SafeHandler.reset(new PragmaSafeHandler()); PP.AddPragmaHandler(SafeHandler.get()); + + PreferInlineHandler.reset(new PragmaPreferInlineHandler()); + PP.AddPragmaHandler(PreferInlineHandler.get()); } void Parser::resetPragmaHandlers() { @@ -649,6 +658,9 @@ void Parser::resetPragmaHandlers() { PP.RemovePragmaHandler(SafeHandler.get()); SafeHandler.reset(); + + PP.RemovePragmaHandler(PreferInlineHandler.get()); + PreferInlineHandler.reset(); } /// Handle the annotation token produced for #pragma unused(...) @@ -1916,6 +1928,14 @@ void Parser::HandlePragmaSafe() { Actions.ActOnPragmaSafe(St); } +void Parser::HandlePragmaPreferInline() { + assert(Tok.is(tok::annot_pragma_prefer_inline)); + Sema::PragmaPreferInlineStatus St = static_cast( + reinterpret_cast(Tok.getAnnotationValue())); + (void)ConsumeAnnotationToken(); + Actions.ActOnPragmaPreferInline(St); +} + // #pragma GCC visibility comes in two variants: // 'push' '(' [visibility] ')' // 'pop' @@ -3940,6 +3960,46 @@ void PragmaSafeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introduc PP.EnterTokenStream(Toks, true, false); } +// #pragma prefer_inline ON +// #pragma prefer_inline OFF +void PragmaPreferInlineHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &PPITok) { + Sema::PragmaPreferInlineStatus St = Sema::PPI_On; + + Token Tok; + PP.Lex(Tok); + if (Tok.isNot(tok::identifier)) { + PP.Diag(Tok.getLocation(), diag::warn_pragma_prefer_inline); + return; + } + SourceLocation EndLoc = Tok.getLocation(); + const IdentifierInfo *II = Tok.getIdentifierInfo(); + if (II->isStr("ON")) { + St = Sema::PPI_On; + PP.Lex(Tok); + } + else if (II->isStr("OFF")) { + St = Sema::PPI_Off; + PP.Lex(Tok); + } else { + PP.Diag(Tok.getLocation(), diag::warn_pragma_prefer_inline); + return; + } + + if (Tok.isNot(tok::eod)) { + PP.Diag(Tok.getLocation(), diag::warn_pragma_prefer_inline); + return; + } + + MutableArrayRef Toks(PP.getPreprocessorAllocator().Allocate(1), 1); + Toks[0].startToken(); + Toks[0].setKind(tok::annot_pragma_prefer_inline); + Toks[0].setLocation(PPITok.getLocation()); + Toks[0].setAnnotationEndLoc(EndLoc); + Toks[0].setAnnotationValue(reinterpret_cast( + static_cast(St))); + PP.EnterTokenStream(Toks, true, false); +} + // Handle '#pragma clang max_tokens 12345'. void PragmaMaxTokensHereHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, diff --git a/clang/lib/Parse/ParseStmt.cpp b/clang/lib/Parse/ParseStmt.cpp index 6dcb9539db10..d18ccad24a9a 100644 --- a/clang/lib/Parse/ParseStmt.cpp +++ b/clang/lib/Parse/ParseStmt.cpp @@ -984,6 +984,8 @@ StmtResult Parser::ParseCompoundStatement(bool isStmtExpr, SafeLoc = ConsumeToken(); } + ResetPreferInlineScopeToNone(); + assert(Tok.is(tok::l_brace) && "Not a compount stmt!"); // Enter a scope to hold everything within the compound stmt. Compound @@ -1056,6 +1058,9 @@ void Parser::ParseCompoundStatementLeadingPragmas() { case tok::annot_pragma_safe: HandlePragmaSafe(); break; + case tok::annot_pragma_prefer_inline: + HandlePragmaPreferInline(); + break; default: checkForPragmas = false; break; @@ -1186,6 +1191,9 @@ StmtResult Parser::ParseCompoundStatementBody(bool isStmtExpr, SafeScopeSpecifie StmtResult R; if (Tok.isNot(tok::kw___extension__)) { R = ParseStatementOrDeclaration(Stmts, SubStmtCtx); + if (Tok.isNot(tok::annot_pragma_prefer_inline) && R.get() != nullptr) { + ResetPreferInlineScopeToNone(); + } } else { // __extension__ can start declarations and it can also be a unary // operator for expressions. Consume multiple __extension__ markers here @@ -1533,6 +1541,8 @@ StmtResult Parser::ParseIfStatement(SourceLocation *TrailingElseLoc) { /*MissingOK=*/false, &LParen, &RParen)) return StmtError(); + ResetPreferInlineScopeToNone(); + if (IsConstexpr) ConstexprCondition = Cond.getKnownValue(); } @@ -1625,6 +1635,8 @@ StmtResult Parser::ParseIfStatement(SourceLocation *TrailingElseLoc) { Sema::ExpressionEvaluationContextRecord::EK_Other, ShouldEnter); ElseStmt = ParseStatement(); + ResetPreferInlineScopeToNone(); + if (ElseStmt.isUsable()) MIChecker.Check(); @@ -1729,6 +1741,8 @@ StmtResult Parser::ParseSwitchStatement(SourceLocation *TrailingElseLoc) { /*MissingOK=*/false, &LParen, &RParen)) return StmtError(); + ResetPreferInlineScopeToNone(); + StmtResult Switch = Actions.ActOnStartOfSwitchStmt( SwitchLoc, LParen, InitStmt.get(), Cond, RParen); @@ -1820,6 +1834,8 @@ StmtResult Parser::ParseWhileStatement(SourceLocation *TrailingElseLoc) { /*MissingOK=*/false, &LParen, &RParen)) return StmtError(); + ResetPreferInlineScopeToNone(); + // C99 6.8.5p5 - In C99, the body of the while statement is a scope, even if // there is no compound stmt. C90 does not have this clause. We only do this // if the body isn't a compound statement to avoid push/pop in common cases. @@ -1879,12 +1895,26 @@ StmtResult Parser::ParseDoStatement() { bool C99orCXX = getLangOpts().C99 || getLangOpts().CPlusPlus; ParseScope InnerScope(this, Scope::DeclScope, C99orCXX, Tok.is(tok::l_brace)); + bool IsPreferInlineStatement = false; + PreferInlineScopeSpecifier PreferInlineState; + if (Actions.GetPragmaPreferInlineInfo() != PI_None) { + IsPreferInlineStatement = true; + PreferInlineState = Actions.GetPragmaPreferInlineInfo(); + Actions.SetPragmaPreferInlineInfo(PI_None); + } + // Read the body statement. StmtResult Body(ParseStatement()); // Pop the body scope if needed. InnerScope.Exit(); + ResetPreferInlineScopeToNone(); + + if (IsPreferInlineStatement) { + Actions.SetPragmaPreferInlineInfo(PreferInlineState); + } + if (Tok.isNot(tok::kw_while)) { if (!Body.isInvalid()) { Diag(Tok, diag::err_expected_while); diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp index d150b95e507a..5df8ce31278f 100644 --- a/clang/lib/Sema/SemaExpr.cpp +++ b/clang/lib/Sema/SemaExpr.cpp @@ -6788,6 +6788,13 @@ ExprResult Sema::ActOnCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc, if (CE) DiagnosedUnqualifiedCallsToStdFunctions(*this, CE); } +#ifdef LLVM_BISHENGCLANGUAGE + CallExpr *CE = dyn_cast(Call.get()); + if (CE) { + PreferInlineScopeSpecifier CallExprSpec = GetPragmaPreferInlineInfo(); + CE->setPreferInlineScopeSpecifier(CallExprSpec); + } +#endif return Call; } diff --git a/clang/lib/Sema/SemaStmt.cpp b/clang/lib/Sema/SemaStmt.cpp index aad4be0165c1..b3fb666b4e6a 100644 --- a/clang/lib/Sema/SemaStmt.cpp +++ b/clang/lib/Sema/SemaStmt.cpp @@ -461,6 +461,16 @@ void Sema::ActOnPragmaSafe(PragmaSafeStatus St) { SetPragmaSafeInfo(spec); } +void Sema::ActOnPragmaPreferInline(PragmaPreferInlineStatus St) { + PreferInlineScopeSpecifier spec = PI_None; + if (St == PSS_On) { + spec = PI_PreferInline; + } else if (St == PSS_Off) { + spec = PI_PreferNoInline; + } + SetPragmaPreferInlineInfo(spec); +} + ExprResult Sema::ActOnCaseExpr(SourceLocation CaseLoc, ExprResult Val) { if (!Val.get()) diff --git a/clang/lib/Serialization/ASTReaderStmt.cpp b/clang/lib/Serialization/ASTReaderStmt.cpp index 8f08c5994d7e..987476e3685a 100644 --- a/clang/lib/Serialization/ASTReaderStmt.cpp +++ b/clang/lib/Serialization/ASTReaderStmt.cpp @@ -1013,6 +1013,9 @@ void ASTStmtReader::VisitCallExpr(CallExpr *E) { if (HasFPFeatures) E->setStoredFPFeatures( FPOptionsOverride::getFromOpaqueInt(Record.readInt())); +#ifdef LLVM_BISHENGCLANGUAGE + E->setPreferInlineScopeSpecifier(static_cast(Record.readInt())); +#endif } void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { diff --git a/clang/lib/Serialization/ASTWriterStmt.cpp b/clang/lib/Serialization/ASTWriterStmt.cpp index e47ce0c26373..77c91550f7df 100644 --- a/clang/lib/Serialization/ASTWriterStmt.cpp +++ b/clang/lib/Serialization/ASTWriterStmt.cpp @@ -873,6 +873,9 @@ void ASTStmtWriter::VisitCallExpr(CallExpr *E) { if (E->hasStoredFPFeatures()) Record.push_back(E->getFPFeatures().getAsOpaqueInt()); Code = serialization::EXPR_CALL; +#ifdef LLVM_BISHENGCLANGUAGE + Record.push_back(E->getPreferInlineScopeSpecifier()); +#endif } void ASTStmtWriter::VisitRecoveryExpr(RecoveryExpr *E) { -- Gitee From 262918b69c1236c702ee874dd9432578cf71e9de Mon Sep 17 00:00:00 2001 From: weixin_93 Date: Tue, 29 Aug 2023 19:51:11 +0800 Subject: [PATCH 3/5] add lto_option_string --- clang/include/clang/Driver/Options.td | 2 ++ clang/include/clang/Lex/PreprocessorOptions.h | 4 ++++ clang/include/clang/Serialization/ASTBitCodes.h | 3 +++ clang/lib/Driver/ToolChains/Clang.cpp | 3 +++ clang/lib/Serialization/ASTReader.cpp | 3 +++ clang/lib/Serialization/ASTWriter.cpp | 13 +++++++++++++ 6 files changed, 28 insertions(+) diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index 2338a5f39105..eb33ca7d9b08 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -1126,6 +1126,8 @@ def fPIC : Flag<["-"], "fPIC">, Group; def fno_PIC : Flag<["-"], "fno-PIC">, Group; def fPIE : Flag<["-"], "fPIE">, Group; def fno_PIE : Flag<["-"], "fno-PIE">, Group; +def opt_string : Joined<["-"], "opt-string=">, Flags<[CC1Option]>, + MarshallingInfoString>; defm access_control : BoolFOption<"access-control", LangOpts<"AccessControl">, DefaultTrue, NegFlag, diff --git a/clang/include/clang/Lex/PreprocessorOptions.h b/clang/include/clang/Lex/PreprocessorOptions.h index 4cf18e98f051..d22442723c57 100644 --- a/clang/include/clang/Lex/PreprocessorOptions.h +++ b/clang/include/clang/Lex/PreprocessorOptions.h @@ -96,6 +96,9 @@ public: /// The implicit PCH included at the start of the translation unit, or empty. std::string ImplicitPCHInclude; + /// Opt string for lto + std::string OptString; + /// Headers that will be converted to chained PCHs in memory. std::vector ChainedIncludes; @@ -251,6 +254,7 @@ public: ChainedIncludes.clear(); DumpDeserializedPCHDecls = false; ImplicitPCHInclude.clear(); + OptString.clear(); SingleFileParseMode = false; LexEditorPlaceholders = true; RetainRemappedFileBuffers = true; diff --git a/clang/include/clang/Serialization/ASTBitCodes.h b/clang/include/clang/Serialization/ASTBitCodes.h index 4963177b62ea..ccfe9f9cfa6f 100644 --- a/clang/include/clang/Serialization/ASTBitCodes.h +++ b/clang/include/clang/Serialization/ASTBitCodes.h @@ -363,6 +363,9 @@ enum ControlRecordTypes { /// Record code for the module build directory. MODULE_DIRECTORY, + + /// Recode code for the bishengc lto opt string + OPT_STRING, }; /// Record types that occur within the options block inside diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp index 69b63800f573..031354a4fab0 100644 --- a/clang/lib/Driver/ToolChains/Clang.cpp +++ b/clang/lib/Driver/ToolChains/Clang.cpp @@ -4794,6 +4794,9 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, if (Args.getLastArg(options::OPT_save_temps_EQ)) Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ); + if (Args.getLastArg(options::OPT_opt_string)) + Args.AddLastArg(CmdArgs, options::OPT_opt_string); + auto *MemProfArg = Args.getLastArg(options::OPT_fmemory_profile, options::OPT_fmemory_profile_EQ, options::OPT_fno_memory_profile); diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp index 6b82e2f7afc2..f5f10b12f883 100644 --- a/clang/lib/Serialization/ASTReader.cpp +++ b/clang/lib/Serialization/ASTReader.cpp @@ -2989,6 +2989,9 @@ ASTReader::ReadControlBlock(ModuleFile &F, F.InputFilesLoaded.resize(NumInputs); F.NumUserInputFiles = NumUserInputs; break; + + case OPT_STRING: + break; } } } diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp index c6be8c29f6c6..21e95ea36b62 100644 --- a/clang/lib/Serialization/ASTWriter.cpp +++ b/clang/lib/Serialization/ASTWriter.cpp @@ -785,6 +785,7 @@ void ASTWriter::WriteBlockInfoBlock() { // Control Block. BLOCK(CONTROL_BLOCK); + RECORD(OPT_STRING); RECORD(METADATA); RECORD(MODULE_NAME); RECORD(MODULE_DIRECTORY); @@ -1199,6 +1200,18 @@ void ASTWriter::WriteControlBlock(Preprocessor &PP, ASTContext &Context, Stream.EnterSubblock(CONTROL_BLOCK_ID, 5); RecordData Record; + // add lto opt string + std::string OptString = PP.getPreprocessorOpts().OptString; + if (!OptString.empty()) { + OptString = OptString + '\0'; + auto Abbrev = std::make_shared(); + Abbrev->Add(BitCodeAbbrevOp(OPT_STRING)); + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); + unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev)); + Record = {OPT_STRING}; + Stream.EmitRecordWithBlob(AbbrevCode, Record, OptString); + Record.clear(); + } // Metadata auto MetadataAbbrev = std::make_shared(); MetadataAbbrev->Add(BitCodeAbbrevOp(METADATA)); -- Gitee From 7aab8388027e1131eadf2b96c7471e5238b6cac3 Mon Sep 17 00:00:00 2001 From: weixin_93 Date: Tue, 29 Aug 2023 20:03:53 +0800 Subject: [PATCH 4/5] rm MACRO_BISHENGC --- clang/include/clang/AST/Expr.h | 3 +-- clang/lib/Sema/SemaExpr.cpp | 12 +++++------- clang/lib/Serialization/ASTReaderStmt.cpp | 2 -- clang/lib/Serialization/ASTWriterStmt.cpp | 2 -- 4 files changed, 6 insertions(+), 13 deletions(-) diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h index 35fcf6078f75..97111056cd46 100644 --- a/clang/include/clang/AST/Expr.h +++ b/clang/include/clang/AST/Expr.h @@ -2867,7 +2867,6 @@ public: static constexpr ADLCallKind NotADL = ADLCallKind::NotADL; static constexpr ADLCallKind UsesADL = ADLCallKind::UsesADL; -#ifdef LLVM_BISHENGCLANGUAGE void setPreferInlineScopeSpecifier(PreferInlineScopeSpecifier PreferInlineSpec) { CallExprBits.PreferInlineSpecifier = PreferInlineSpec; } @@ -2875,7 +2874,7 @@ public: PreferInlineScopeSpecifier getPreferInlineScopeSpecifier() const { return (PreferInlineScopeSpecifier) CallExprBits.PreferInlineSpecifier; } -#endif + protected: /// Build a call expression, assuming that appropriate storage has been /// allocated for the trailing objects. diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp index 5df8ce31278f..23a816717ef3 100644 --- a/clang/lib/Sema/SemaExpr.cpp +++ b/clang/lib/Sema/SemaExpr.cpp @@ -6788,13 +6788,11 @@ ExprResult Sema::ActOnCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc, if (CE) DiagnosedUnqualifiedCallsToStdFunctions(*this, CE); } -#ifdef LLVM_BISHENGCLANGUAGE - CallExpr *CE = dyn_cast(Call.get()); - if (CE) { - PreferInlineScopeSpecifier CallExprSpec = GetPragmaPreferInlineInfo(); - CE->setPreferInlineScopeSpecifier(CallExprSpec); - } -#endif + CallExpr *CE = dyn_cast(Call.get()); + if (CE) { + PreferInlineScopeSpecifier CallExprSpec = GetPragmaPreferInlineInfo(); + CE->setPreferInlineScopeSpecifier(CallExprSpec); + } return Call; } diff --git a/clang/lib/Serialization/ASTReaderStmt.cpp b/clang/lib/Serialization/ASTReaderStmt.cpp index 987476e3685a..484e84ddfb63 100644 --- a/clang/lib/Serialization/ASTReaderStmt.cpp +++ b/clang/lib/Serialization/ASTReaderStmt.cpp @@ -1013,9 +1013,7 @@ void ASTStmtReader::VisitCallExpr(CallExpr *E) { if (HasFPFeatures) E->setStoredFPFeatures( FPOptionsOverride::getFromOpaqueInt(Record.readInt())); -#ifdef LLVM_BISHENGCLANGUAGE E->setPreferInlineScopeSpecifier(static_cast(Record.readInt())); -#endif } void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { diff --git a/clang/lib/Serialization/ASTWriterStmt.cpp b/clang/lib/Serialization/ASTWriterStmt.cpp index 77c91550f7df..e38e3b006cec 100644 --- a/clang/lib/Serialization/ASTWriterStmt.cpp +++ b/clang/lib/Serialization/ASTWriterStmt.cpp @@ -873,9 +873,7 @@ void ASTStmtWriter::VisitCallExpr(CallExpr *E) { if (E->hasStoredFPFeatures()) Record.push_back(E->getFPFeatures().getAsOpaqueInt()); Code = serialization::EXPR_CALL; -#ifdef LLVM_BISHENGCLANGUAGE Record.push_back(E->getPreferInlineScopeSpecifier()); -#endif } void ASTStmtWriter::VisitRecoveryExpr(RecoveryExpr *E) { -- Gitee From 6f5c5076c48ce0014ec30d51e0656196c627f688 Mon Sep 17 00:00:00 2001 From: weixin_93 Date: Tue, 29 Aug 2023 20:05:41 +0800 Subject: [PATCH 5/5] rm MACRO_BISHENGC --- clang/lib/AST/TextNodeDumper.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/clang/lib/AST/TextNodeDumper.cpp b/clang/lib/AST/TextNodeDumper.cpp index 7752d97bbf02..c1fc4bba8ce2 100644 --- a/clang/lib/AST/TextNodeDumper.cpp +++ b/clang/lib/AST/TextNodeDumper.cpp @@ -1004,13 +1004,11 @@ void TextNodeDumper::VisitCallExpr(const CallExpr *Node) { OS << " adl"; if (Node->hasStoredFPFeatures()) printFPOptions(Node->getFPFeatures()); -#ifdef LLVM_BISHENGCLANGUAGE if (Node->getPreferInlineScopeSpecifier() == PI_PreferInline) { OS << " prefer_inline"; } else if (Node->getPreferInlineScopeSpecifier() == PI_PreferNoInline) { OS << " prefer_no_inline"; } -#endif } void TextNodeDumper::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *Node) { -- Gitee