Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package clang-extract for openSUSE:Factory checked in at 2024-08-02 17:27:18 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/clang-extract (Old) and /work/SRC/openSUSE:Factory/.clang-extract.new.7232 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "clang-extract" Fri Aug 2 17:27:18 2024 rev:10 rq:1191106 version:0~20240801.6cf5b73 Changes: -------- --- /work/SRC/openSUSE:Factory/clang-extract/clang-extract.changes 2024-08-01 22:05:50.719970549 +0200 +++ /work/SRC/openSUSE:Factory/.clang-extract.new.7232/clang-extract.changes 2024-08-02 17:28:00.566967554 +0200 @@ -1,0 +2,10 @@ +Fri Aug 02 06:34:40 UTC 2024 - mvetter@suse.com + +- Update to version 0~20240801.6cf5b73: + * libcextract: Passes: Drop attributes when creating the KLP_RELOC entries + * SymbolExternalizer: Drop initializer from expanded macros + * libcextract: ArgvParser: Use vmlinux on PatchObject when DEBUGINFO is different + * libcextract: Passes.cpp: Use vmlinux if sym_mod is empty + * Drop klpe_ prefix for extern function symbols + +------------------------------------------------------------------- Old: ---- clang-extract-0~20240731.94276b7.tar.xz New: ---- clang-extract-0~20240801.6cf5b73.tar.xz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ clang-extract.spec ++++++ --- /var/tmp/diff_new_pack.LxQQZj/_old 2024-08-02 17:28:00.970984218 +0200 +++ /var/tmp/diff_new_pack.LxQQZj/_new 2024-08-02 17:28:00.970984218 +0200 @@ -17,7 +17,7 @@ Name: clang-extract -Version: 0~20240731.94276b7 +Version: 0~20240801.6cf5b73 Release: 0 Summary: A tool to extract code content from source files License: Apache-2.0 WITH LLVM-exception AND NCSA ++++++ _service ++++++ --- /var/tmp/diff_new_pack.LxQQZj/_old 2024-08-02 17:28:01.006985703 +0200 +++ /var/tmp/diff_new_pack.LxQQZj/_new 2024-08-02 17:28:01.010985868 +0200 @@ -2,7 +2,7 @@ <service name="tar_scm" mode="manual"> <param name="scm">git</param> <param name="url">https://github.com/SUSE/clang-extract</param> - <param name="revision">94276b701c40beb0edd4cac490d8ac74e53d86fb</param> + <param name="revision">6cf5b73ebe772a2727a1e65d4243c3c6ff1a5856</param> <param name="versionformat">0~%cd.%h</param> <param name="changesgenerate">enable</param> <param name="changesauthor">mvetter@suse.com</param> ++++++ clang-extract-0~20240731.94276b7.tar.xz -> clang-extract-0~20240801.6cf5b73.tar.xz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/clang-extract-0~20240731.94276b7/libcextract/ArgvParser.cpp new/clang-extract-0~20240801.6cf5b73/libcextract/ArgvParser.cpp --- old/clang-extract-0~20240731.94276b7/libcextract/ArgvParser.cpp 2024-07-31 19:59:31.000000000 +0200 +++ new/clang-extract-0~20240801.6cf5b73/libcextract/ArgvParser.cpp 2024-08-01 21:54:30.000000000 +0200 @@ -19,6 +19,8 @@ #include <clang/Basic/Version.h> +#include <filesystem> + #ifndef CLANG_VERSION_MAJOR # error "Unable to find clang version" #endif @@ -82,6 +84,17 @@ } Insert_Required_Parameters(); + + /* For kernel, check if the object patch is not the same as DebugInfo. If they + * are not the same, it means that the module from PatchObject is builtin, so + * assign vmlinux to PatchObject. */ + if (Kernel && DebuginfoPath) { + std::string obj_path = std::filesystem::path(DebuginfoPath).filename(); + /* As the DebugInfo can point to a file with suffix (btrfs.ko for example), + * check the substring */ + if (obj_path.find(PatchObject) == std::string::npos) + PatchObject = "vmlinux"; + } } void ArgvParser::Insert_Required_Parameters(void) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/clang-extract-0~20240731.94276b7/libcextract/Passes.cpp new/clang-extract-0~20240801.6cf5b73/libcextract/Passes.cpp --- old/clang-extract-0~20240731.94276b7/libcextract/Passes.cpp 2024-07-31 19:59:31.000000000 +0200 +++ new/clang-extract-0~20240801.6cf5b73/libcextract/Passes.cpp 2024-08-01 21:54:30.000000000 +0200 @@ -26,6 +26,7 @@ #include "NonLLVMMisc.hh" #include "Error.hh" #include "HeaderGenerate.hh" +#include "LLVMMisc.hh" #include "clang/Frontend/ASTUnit.h" #include "clang/Frontend/CompilerInstance.h" @@ -105,6 +106,27 @@ "." + std::string(PassName) + extension; } +static std::string Get_Output_From_Input_File(std::string &input) +{ + std::string work = input; + + size_t last_dot = work.find_last_of("."); + std::string no_extension = work.substr(0, last_dot); + std::string extension = work.substr(last_dot, work.length()); + + return no_extension + ".CE" + extension; +} + +static std::string Get_Output_Path(PassManager::Context *ctx) +{ + std::string output_path = ctx->OutputFile; + if (output_path == "") { + output_path = Get_Output_From_Input_File(ctx->InputPath); + } + + return output_path; +} + /** BuildASTPass: Built the AST object and store it into the Context object. * * This may be the first pass of the pass queue, as the AST object is used by @@ -277,17 +299,6 @@ ctx->FuncExtractNames.size() > 0; } - std::string Get_Output_From_Input_File(std::string &input) - { - std::string work = input; - - size_t last_dot = work.find_last_of("."); - std::string no_extension = work.substr(0, last_dot); - std::string extension = work.substr(last_dot, work.length()); - - return no_extension + ".CE" + extension; - } - virtual bool Run_Pass(PassManager::Context *ctx) { ctx->CodeOutput = std::string(); @@ -331,10 +342,7 @@ /* Set output stream to a file if we set to print to a file. */ if (PrintToFile) { - std::string output_path = ctx->OutputFile; - if (output_path == "") { - output_path = Get_Output_From_Input_File(ctx->InputPath); - } + std::string output_path = Get_Output_Path(ctx); PrettyPrint::Set_Output_To(output_path); } else { ctx->CodeOutput = std::string(); @@ -459,16 +467,6 @@ ClangCompat_None, ctx->OFS); PrettyPrint::Set_AST(ctx->AST.get()); - if (ctx->Ibt && ctx->AST && externalizer.Has_Externalizations()) { - /* Do a sanity check on IBT macros. Some kernel branches can't use it, - so do a check here for sanity reasons. */ - Preprocessor &pp = ctx->AST->getPreprocessor(); - if (pp.isMacroDefined("KLP_RELOC_SYMBOL") == false) { - throw std::runtime_error("KLP_RELOC_SYMBOL not defined, kernel may not " - "be compatible with IBT."); - } - } - const DiagnosticsEngine &de = ctx->AST->getDiagnostics(); return !de.hasErrorOccurred(); } @@ -528,6 +526,70 @@ } }; + +/** IbtTailGeneratePass: Generate the tail content of the output file when IBT + * is enabled. + */ +class IbtTailGeneratePass : public Pass +{ +public: + IbtTailGeneratePass(void) + { + PassName = "IbtTailGeneratePass"; + } + + virtual bool Gate(PassManager::Context *ctx) + { + return ctx->Ibt && ctx->Externalize.size() > 0; + } + + virtual bool Run_Pass(PassManager::Context *ctx) + { + PrettyPrint::Print_Raw("/* ---- IBT Tail Content ---- */\n\n"); + PrettyPrint::Print_Raw( + "#define KLP_RELOC_SYMBOL_POS(LP_OBJ_NAME, SYM_OBJ_NAME, SYM_NAME, SYM_POS) \\\n" + "\tasm(\"\\\".klp.sym.rela.\" #LP_OBJ_NAME \".\" #SYM_OBJ_NAME \".\" #SYM_NAME \",\" #SYM_POS \"\\\"\")\n" + "#define KLP_RELOC_SYMBOL(LP_OBJ_NAME, SYM_OBJ_NAME, SYM_NAME) \\\n" + "\tKLP_RELOC_SYMBOL_POS(LP_OBJ_NAME, SYM_OBJ_NAME, SYM_NAME, 0)\n\n"); + + for (const ExternalizerLogEntry &entry : ctx->NamesLog) { + if (entry.Type == ExternalizationType::STRONG) { + DeclContextLookupResult decls = Get_Decl_From_Symtab(ctx->AST.get(), + entry.NewName); + + for (auto decl : decls) { + /* Make sure our declaration is a DeclaratorDecl (variable or function). */ + if (!isa<DeclaratorDecl>(decl)) { + continue; + } + + std::string o; + llvm::raw_string_ostream outstr(o); + + std::string sym_mod = ctx->IA.Get_Symbol_Module(entry.OldName); + if (sym_mod.empty()) + sym_mod = "vmlinux"; + + decl->dropAttrs(); + decl->print(outstr); + + outstr << " \\\n" << "\tKLP_RELOC_SYMBOL(" << ctx->PatchObject << ", " << + sym_mod << ", " << entry.OldName << ");\n\n"; + + PrettyPrint::Print_Raw(o); + } + } + } + + return true; + } + + virtual void Dump_Result(PassManager::Context *ctx) + { + /* The dump is the generated file itself. */ + } +}; + class HeaderGenerationPass : public Pass { public: @@ -572,6 +634,7 @@ new FunctionExternalizerPass(), new GenerateDscPass(), new ClosurePass(/*PrintToFile=*/true), + new IbtTailGeneratePass(), new HeaderGenerationPass(), }; } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/clang-extract-0~20240731.94276b7/libcextract/SymbolExternalizer.cpp new/clang-extract-0~20240801.6cf5b73/libcextract/SymbolExternalizer.cpp --- old/clang-extract-0~20240731.94276b7/libcextract/SymbolExternalizer.cpp 2024-07-31 19:59:31.000000000 +0200 +++ new/clang-extract-0~20240801.6cf5b73/libcextract/SymbolExternalizer.cpp 2024-08-01 21:54:30.000000000 +0200 @@ -121,23 +121,26 @@ ExternalizationType type = sym->ExtType; if (type == ExternalizationType::STRONG) { if (!sym->Done) { + /* If we are dealing with a symbol that is a function, and we are + * extracting code with IBT set, do not change the function now with a + * prefix. This helps to reduce the number of expanded headers, and also + * helps to match the code extracted with teh original source code. + */ std::string sym_name = decl->getName().str(); + const std::string new_name = SE.Ibt ? sym_name + : EXTERNALIZED_PREFIX + sym_name; + DeclaratorDecl *new_decl = SE.Create_Externalized_Var(decl, new_name); /* If we found the first instance of the function we want to externalize, then proceed to annotate the Decl so we can later decide what to do with it. */ - const std::string new_name = EXTERNALIZED_PREFIX + sym_name; - DeclaratorDecl *new_decl = SE.Create_Externalized_Var(decl, new_name); sym->NewName = new_name; sym->OldDecl = decl; sym->NewDecl = new_decl; - SE.Log.push_back({.OldName = sym_name, - .NewName = new_name, - .Type = type}); - - sym->Done = true; sym->Wrap = !SE.Ibt; + /* Log entry is added in Late_Externalize(), once we may discard + externalizations due to it not being covered by the closure. */ } } else if (type == ExternalizationType::WEAK) { /* Now checks if this is a function or a variable delcaration. */ @@ -203,7 +206,7 @@ * Only execute the code in the visitor if we have already externalized the * symbol */ - if (sym == nullptr || !sym->Done) + if (sym == nullptr) return VISITOR_CONTINUE; /* Get the first effective use, which means an DeclRefExpr of a decl that @@ -224,7 +227,7 @@ /* We must be careful to ensure that the reference we got is actually written cleanly, e.g. it doesn't come from a macro expansion. */ - if (sym_name == PrettyPrint::Get_Source_Text(range)) { + if (sym_name == PrettyPrint::Get_Source_Text(range) && sym->Needs_Sym_Rename()) { /* Issue a text modification. */ SE.Replace_Text(range, sym->getUseName(), 100); } @@ -279,6 +282,41 @@ return false; } +template <typename DECL> +bool SymbolExternalizer::Drop_Static_Add_Extern(DECL *decl) +{ + if (decl->getStorageClass() == StorageClass::SC_Static) { + auto ids = Get_Range_Of_Identifier(decl->getSourceRange(), StringRef("static")); + assert(ids.size() > 0 && "static decl without static keyword?"); + + SourceRange static_range = ids[0].second; + Replace_Text(static_range, "extern", 10); + + /* Update the storage class. */ + decl->setStorageClass(StorageClass::SC_Extern); + + return true; + } + + return false; +} + +template <typename DECL> +bool SymbolExternalizer::Add_Extern(DECL *decl) +{ + StorageClass storage = decl->getStorageClass(); + if (storage == StorageClass::SC_Static) { + Drop_Static_Add_Extern(decl); + return true; + } else if (storage == StorageClass::SC_None) { + Insert_Text(decl->getBeginLoc(), "extern "); + decl->setStorageClass(StorageClass::SC_Extern); + return true; + } + + return false; +} + /* ---- Delta and TextModifications class ------ */ @@ -722,7 +760,7 @@ if (!maybe_macro && !MacroWalker::Is_Identifier_Macro_Argument(info, id_info)) { SymbolUpdateStatus *sym = getSymbolsUpdateStatus(id_info->getName()); - if (sym) + if (sym && sym->Needs_Sym_Rename()) Replace_Text(SourceRange(tok.getLocation(), tok.getLastLoc()), sym->getUseName(), 10); } } @@ -734,7 +772,8 @@ for (auto &tok_range : ranges) { // At this point, tok_range will contain a valid symbol SymbolUpdateStatus *sym = getSymbolsUpdateStatus(tok_range.first); - Replace_Text(tok_range.second, sym->getUseName(), 10); + if (sym->Needs_Sym_Rename()) + Replace_Text(tok_range.second, sym->getUseName(), 10); } } } @@ -817,6 +856,78 @@ } } +void SymbolExternalizer::Drop_Function_Body(FunctionDecl *decl) +{ + if (decl->doesThisDeclarationHaveABody()) { + Stmt *body = decl->getBody(); + Replace_Text(body->getSourceRange(), ";", 1000); + } +} + +void SymbolExternalizer::Drop_Var_Initializer(VarDecl *decl) +{ + if (decl->hasInit() && decl->getInitStyle() == VarDecl::InitializationStyle::CInit) { + Expr *init = decl->getInit(); + SourceLocation init_loc = init->getSourceRange().getBegin(); + SourceLocation head = init_loc.getLocWithOffset(-1); + + StringRef text = PrettyPrint::Get_Source_Text(init->getSourceRange()); + if (text.data() == nullptr) { + std::string o; + llvm::raw_string_ostream outstr(o); + + decl->setInit(nullptr); + decl->print(outstr); + decl->setInit(init); + + Replace_Text(decl->getSourceRange(), o, 1000); + return; + } + + /* Search for the '=' initializer token. */ + while (true) { + StringRef text = PrettyPrint::Get_Source_Text({head, init_loc}); + if (*text.data() == '=') { + break; + } + head = head.getLocWithOffset(-1); + } + + Replace_Text({head, init->getSourceRange().getEnd()}, ";", 1000); + } +} + +void SymbolExternalizer::Handle_IBT_Ext(SymbolUpdateStatus *sym) +{ + /* Get the last usage (more recent decl), and check if it was the + * first usage. If yes, drop the declartion and use the NewDecl form + * SymbolUpdateStatus. + * + * For functions, drop the declarations and change the later + * prototypes to have the extern storage type. + * + * For variables, remove all references but the first one, because + * this will also be replaced by outstr (NewDecl from + * SymbolUpdateStatus). + */ + Decl *ibt_decl = sym->OldDecl->getMostRecentDecl(); + if (FunctionDecl *func = dyn_cast<FunctionDecl>(ibt_decl)) { + while (func) { + Drop_Function_Body(func); + Drop_Static_Add_Extern(func); + + func = func->getPreviousDecl(); + } + } else if (VarDecl *var = dyn_cast<VarDecl>(ibt_decl)) { + while (var) { + Add_Extern(var); + Drop_Var_Initializer(var); + + var = var->getPreviousDecl(); + } + } +} + void SymbolExternalizer::Late_Externalize(void) { SymbolExternalizer &SE = *this; @@ -831,24 +942,24 @@ continue; } + if (Ibt) { + /* When IBT is enabled we handle things a little differently. We don't + do Late Externalization but rather change the symbols in where they + were defined once we need to change them to extern and drop bodies. */ + Handle_IBT_Ext(sym); + + /* Remember that we externalized it. */ + Log.push_back({.OldName = sym->OldDecl->getName().str(), + .NewName = sym->NewDecl->getName().str(), + .Type = sym->ExtType}); + continue; + } + /* Create a string with the new variable type and name. */ std::string o; llvm::raw_string_ostream outstr(o); /* - * It won't be a problem to add the code below multiple times, since - * clang-extract will remove ifndefs for already defined macros - */ - if (SE.Ibt) { - outstr << "#ifndef KLP_RELOC_SYMBOL_POS\n" - "# define KLP_RELOC_SYMBOL_POS(LP_OBJ_NAME, SYM_OBJ_NAME, SYM_NAME, SYM_POS) \\\n" - " asm(\"\\\".klp.sym.rela.\" #LP_OBJ_NAME \".\" #SYM_OBJ_NAME \".\" #SYM_NAME \",\" #SYM_POS \"\\\"\")\n" - "# define KLP_RELOC_SYMBOL(LP_OBJ_NAME, SYM_OBJ_NAME, SYM_NAME) \\\n" - " KLP_RELOC_SYMBOL_POS(LP_OBJ_NAME, SYM_OBJ_NAME, SYM_NAME, 0)\n" - "#endif\n\n"; - } - - /* * Get the location of the original decl so we can output the right comment * location when LateExternalization is active. */ @@ -858,14 +969,6 @@ sym->NewDecl->print(outstr); std::string sym_name = sym->OldDecl->getName().str(); - if (SE.Ibt) { - std::string sym_mod = SE.IA.Get_Symbol_Module(sym_name); - if (sym_mod == "") - sym_mod = "vmlinux"; - - outstr << " \\\n" << "\tKLP_RELOC_SYMBOL(" << SE.PatchObject << ", " << - sym_mod << ", " << sym_name << ")"; - } outstr << ";\n"; /* In case we successfully have a late insertion location, put the new decl @@ -888,6 +991,11 @@ DiagsClass::Emit_Warn(msg); } } + + /* Remember that we externalized it. */ + Log.push_back({.OldName = sym->OldDecl->getName().str(), + .NewName = sym->NewDecl->getName().str(), + .Type = sym->ExtType}); } } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/clang-extract-0~20240731.94276b7/libcextract/SymbolExternalizer.hh new/clang-extract-0~20240801.6cf5b73/libcextract/SymbolExternalizer.hh --- old/clang-extract-0~20240731.94276b7/libcextract/SymbolExternalizer.hh 2024-07-31 19:59:31.000000000 +0200 +++ new/clang-extract-0~20240801.6cf5b73/libcextract/SymbolExternalizer.hh 2024-08-01 21:54:30.000000000 +0200 @@ -100,6 +100,15 @@ return OldDecl && NewDecl && FirstUse; } + /* For IBT, NewDecl and OldDecl are the same if the symbols is a function, so + don't replace text if the name didn't change. */ + inline bool Needs_Sym_Rename(void) { + if (NewDecl == nullptr) + return true; + + return NewDecl->getName() != OldDecl->getName(); + } + void Dump(SourceManager &SM) { llvm::outs() << "SymbolUpdateStatus at 0x" << this << '\n'; @@ -323,9 +332,16 @@ SymbolUpdateStatus *getSymbolsUpdateStatus(const StringRef &sym); - /* Drop `static` keyword in decl. */ bool Drop_Static(FunctionDecl *decl); + /* Replace `static` keyword in decl with extern. */ + template <typename DECL> + bool Add_Extern(DECL *decl); + + /* Replace `static` keyword in decl with extern. */ + template <typename DECL> + bool Drop_Static_Add_Extern(DECL *decl); + /** Commit changes to the loaded source file buffer. Should NOT modify the original file, only the content that was loaded in llvm's InMemory file system. */ @@ -376,6 +392,15 @@ void Remove_Text(const SourceRange &range, int priority); void Insert_Text(const SourceLocation &range, StringRef text); + /** Drop body of function. */ + void Drop_Function_Body(FunctionDecl *decl); + + /** Drop Variable Initializer. */ + void Drop_Var_Initializer(VarDecl *decl); + + /** Handle externalization on IBT case. */ + void Handle_IBT_Ext(SymbolUpdateStatus *); + /** AST in analysis. */ ASTUnit *AST; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/clang-extract-0~20240731.94276b7/testsuite/linux/ibt-1.c new/clang-extract-0~20240801.6cf5b73/testsuite/linux/ibt-1.c --- old/clang-extract-0~20240731.94276b7/testsuite/linux/ibt-1.c 2024-07-31 19:59:31.000000000 +0200 +++ new/clang-extract-0~20240801.6cf5b73/testsuite/linux/ibt-1.c 2024-08-01 21:54:30.000000000 +0200 @@ -14,6 +14,6 @@ return 0; } -/* { dg-final { scan-tree-dump "u32 klpe_crc32c|u32 \(klpe_crc32c\)" } } */ +/* { dg-final { scan-tree-dump "u32 crc32c\(" } } */ /* { dg-final { scan-tree-dump "KLP_RELOC_SYMBOL\(libcrc32c, libcrc32c, crc32c\)" } } */ /* { dg-final { scan-tree-dump-not "\(\*klpe_crc32c\)" } } */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/clang-extract-0~20240731.94276b7/testsuite/linux/ibt-2.c new/clang-extract-0~20240801.6cf5b73/testsuite/linux/ibt-2.c --- old/clang-extract-0~20240731.94276b7/testsuite/linux/ibt-2.c 2024-07-31 19:59:31.000000000 +0200 +++ new/clang-extract-0~20240801.6cf5b73/testsuite/linux/ibt-2.c 2024-08-01 21:54:30.000000000 +0200 @@ -14,6 +14,6 @@ return 0; } -/* { dg-final { scan-tree-dump "u32 klpe_crc32c|u32 \(klpe_crc32c\)" } } */ +/* { dg-final { scan-tree-dump "u32 crc32c\(" } } */ /* { dg-final { scan-tree-dump "KLP_RELOC_SYMBOL\(libcrc32c, libcrc32c, crc32c\)" } } */ /* { dg-final { scan-tree-dump-not "\(\*klpe_crc32c\)" } } */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/clang-extract-0~20240731.94276b7/testsuite/linux/ibt-typeof-1.c new/clang-extract-0~20240801.6cf5b73/testsuite/linux/ibt-typeof-1.c --- old/clang-extract-0~20240731.94276b7/testsuite/linux/ibt-typeof-1.c 2024-07-31 19:59:31.000000000 +0200 +++ new/clang-extract-0~20240801.6cf5b73/testsuite/linux/ibt-typeof-1.c 2024-08-01 21:54:30.000000000 +0200 @@ -15,7 +15,7 @@ return 0; } -/* { dg-final { scan-tree-dump "u32 klpe_crc32c|u32 \(klpe_crc32c\)" } } */ +/* { dg-final { scan-tree-dump "u32 crc32c\(" } } */ /* { dg-final { scan-tree-dump "KLP_RELOC_SYMBOL\(libcrc32c, libcrc32c, crc32c\)" } } */ -/* { dg-final { scan-tree-dump "typeof\(klpe_crc32c\)" } } */ +/* { dg-final { scan-tree-dump "typeof\(crc32c\)" } } */ /* { dg-final { scan-tree-dump-not "\(\*klpe_crc32c\)" } } */