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 - mvet...@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">mvet...@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\)" } } */
