diff --git a/doc/manuals/abidiff.rst b/doc/manuals/abidiff.rst
index 0c711d9e..5d0834cd 100644
--- a/doc/manuals/abidiff.rst
+++ b/doc/manuals/abidiff.rst
@@ -12,11 +12,12 @@ This tool can also compare the textual representations of the ABI of
 two ELF binaries (as emitted by ``abidw``) or an ELF binary against a
 textual representation of another ELF binary.
 
-For a comprehensive ABI change report that includes changes about
-function and variable sub-types, the two input shared libraries must
-be accompanied with their debug information in `DWARF`_ format.
-Otherwise, only `ELF`_ symbols that were added or removed are
-reported.
+For a comprehensive ABI change report between two input shared
+libraries that includes changes about function and variable sub-types,
+``abidiff`` uses by default, debug information in `DWARF`_ format, if
+present, otherwise it compares interfaces using debug information in
+`CTF`_ format, if present. Finally, if neither is found, only `ELF`_
+symbols that were added or removed are reported.
 
 .. include:: tools-use-libabigail.txt
 
@@ -558,7 +559,7 @@ Options
 
   * ``--ctf``
 
-    When comparing binaries, extract ABI information from CTF debug
+    When comparing binaries, extract ABI information from `CTF`_ debug
     information, if present.
 
   * ``--stats``
@@ -785,4 +786,4 @@ Usage examples
 
 .. _ELF: http://en.wikipedia.org/wiki/Executable_and_Linkable_Format
 .. _DWARF: http://www.dwarfstd.org
-
+.. _CTF: https://raw.githubusercontent.com/wiki/oracle/binutils-gdb/files/ctf-spec.pdf
diff --git a/doc/manuals/abidw.rst b/doc/manuals/abidw.rst
index a3055c7e..c162ef25 100644
--- a/doc/manuals/abidw.rst
+++ b/doc/manuals/abidw.rst
@@ -8,8 +8,7 @@ representation of its ABI to standard output.  The emitted
 representation format, named ``ABIXML``, includes all the globally
 defined functions and variables, along with a complete representation
 of their types.  It also includes a representation of the globally
-defined ELF symbols of the file.  The input shared library must
-contain associated debug information in `DWARF`_ format.
+defined ELF symbols of the file.
 
 When given the ``--linux-tree`` option, this program can also handle a
 `Linux kernel`_ tree.  That is, a directory tree that contains both
@@ -19,8 +18,13 @@ interface between the kernel and its module, to standard output.  In
 this case, we don't call it an ABI, but a KMI (Kernel Module
 Interface).  The emitted KMI includes all the globally defined
 functions and variables, along with a complete representation of their
-types.  The input binaries must contain associated debug information
-in `DWARF`_ format.
+types.
+
+To generate the ABI or KMI representation, by default ``abidw`` uses
+debug information in the `DWARF`_ format, if present, otherwise it
+looks for the debug information in the `CTF`_ format.  Finally, if
+neither is found, it only reports which `ELF`_ symbols were added or
+removed.
 
 .. include:: tools-use-libabigail.txt
 
@@ -326,7 +330,7 @@ Options
 
   * ``--ctf``
 
-    Extract ABI information from CTF debug information, if present in
+    Extract ABI information from `CTF`_ debug information, if present in
     the given object.
 
   *  ``--annotate``
@@ -365,3 +369,4 @@ standard `here
 .. _DWARF: http://www.dwarfstd.org
 .. _GNU: http://www.gnu.org
 .. _Linux Kernel: https://kernel.org/
+.. _CTF: https://raw.githubusercontent.com/wiki/oracle/binutils-gdb/files/ctf-spec.pdf
diff --git a/doc/manuals/abipkgdiff.rst b/doc/manuals/abipkgdiff.rst
index 9114775a..086762d5 100644
--- a/doc/manuals/abipkgdiff.rst
+++ b/doc/manuals/abipkgdiff.rst
@@ -13,12 +13,18 @@ binaries.
 For a comprehensive ABI change report that includes changes about
 function and variable sub-types, the two input packages must be
 accompanied with their debug information packages that contain debug
-information either in `DWARF`_ or in `CTF` formats.  Please note
+information either in `DWARF`_ or in `CTF`_ formats.  Please note
 however that some packages contain binaries that embed the debug
 information directly in a section of said binaries.  In those cases,
 obviously, no separate debug information package is needed as the tool
 will find the debug information inside the binaries.
 
+By default, ``abipkgdiff`` uses the debug information in `DWARF`_
+format, if present, otherwise it compares binaries interfaces using
+debug information in `CTF`_ format, if present.  Finally, if neither
+is found, it uses only reports about `ELF`_ symbols that were added or
+removed.
+
 .. include:: tools-use-libabigail.txt
 
 .. _abipkgdiff_invocation_label:
@@ -525,8 +531,8 @@ Options
 
   * ``--ctf``
 
-     This is used to compare packages with CTF debug information, if
-     present.
+     This is used to compare packages with `CTF`_ debug information,
+     if present.
 
 .. _abipkgdiff_return_value_label:
 
@@ -546,4 +552,5 @@ In the later case, the value of the exit code is the same as for the
 .. _Deb: https://en.wikipedia.org/wiki/Deb_%28file_format%29
 .. _tar: https://en.wikipedia.org/wiki/Tar_%28computing%29
 .. _DWARF: http://www.dwarfstd.org
+.. _CTF: https://raw.githubusercontent.com/wiki/oracle/binutils-gdb/files/ctf-spec.pdf
 .. _Development Package: https://fedoraproject.org/wiki/Packaging:Guidelines?rd=Packaging/Guidelines#Devel_Packages
diff --git a/doc/manuals/kmidiff.rst b/doc/manuals/kmidiff.rst
index 53010189..4059c71f 100644
--- a/doc/manuals/kmidiff.rst
+++ b/doc/manuals/kmidiff.rst
@@ -74,6 +74,11 @@ functions and variables) between the Kernel and its modules.  In
 practice, though, some users might want to compare a subset of the
 those interfaces.
 
+By default, ``kmidiff`` uses the debug information in `DWARF`_ format,
+if present, otherwise it compares interfaces using debug information
+in `CTF`_ format, if present.  Finally, if neither is found, it only
+reports about `ELF`_ symbols that were added or removed.
+
 Users can then define a "white list" of the interfaces to compare.
 Such a white list is a just a file in the "INI" format that looks
 like: ::
@@ -174,7 +179,7 @@ Options
 
   * ``--ctf``
 
-    Extract ABI information from CTF debug information, if present in
+    Extract ABI information from `CTF`_ debug information, if present in
     the Kernel and Modules.
 
   * ``--impacted-interfaces | -i``
@@ -242,3 +247,5 @@ Options
 .. _ELF: http://en.wikipedia.org/wiki/Executable_and_Linkable_Format
 .. _ksymtab: http://en.wikipedia.org/wiki/Executable_and_Linkable_Format
 .. _Linux Kernel: https://kernel.org
+.. _DWARF: http://www.dwarfstd.org
+.. _CTF: https://raw.githubusercontent.com/wiki/oracle/binutils-gdb/files/ctf-spec.pdf
diff --git a/include/abg-tools-utils.h b/include/abg-tools-utils.h
index 27bbfefe..391a389a 100644
--- a/include/abg-tools-utils.h
+++ b/include/abg-tools-utils.h
@@ -297,6 +297,10 @@ bool
 file_is_kernel_debuginfo_package(const string& file_path,
 				 file_type file_type);
 
+bool
+dir_contains_ctf_archive(const string& directory,
+			 const string& archive_prefix);
+
 std::shared_ptr<char>
 make_path_absolute(const char*p);
 
diff --git a/src/abg-ctf-reader.cc b/src/abg-ctf-reader.cc
index e307fcd7..bcd011d3 100644
--- a/src/abg-ctf-reader.cc
+++ b/src/abg-ctf-reader.cc
@@ -45,6 +45,7 @@ namespace ctf_reader
 using std::dynamic_pointer_cast;
 using abigail::tools_utils::dir_name;
 using abigail::tools_utils::file_exists;
+using abigail::tools_utils::base_name;
 
 class read_context
 {
@@ -1524,7 +1525,12 @@ slurp_elf_info(read_context *ctxt,
   corp->set_architecture_name(elf_helpers::e_machine_to_string(ehdr->e_machine));
 
   find_alt_debuginfo(ctxt, &ctf_dbg_scn);
-  ABG_ASSERT(ctxt->symtab);
+  if (!ctxt->symtab)
+    {
+      status |= elf_reader::STATUS_NO_SYMBOLS_FOUND;
+      return;
+    }
+
   corp->set_symtab(ctxt->symtab);
 
   if ((corp->get_origin() & corpus::LINUX_KERNEL_BINARY_ORIGIN)
@@ -1543,7 +1549,8 @@ slurp_elf_info(read_context *ctxt,
         ctf_scn = ctf_dbg_scn;
       else
         {
-          status |= elf_reader::STATUS_DEBUG_INFO_NOT_FOUND;
+          status |= (elf_reader::STATUS_OK |
+                     elf_reader::STATUS_DEBUG_INFO_NOT_FOUND);
           return;
         }
     }
@@ -1655,15 +1662,15 @@ read_corpus(read_context *ctxt, elf_reader::status &status)
     origin |= corpus::LINUX_KERNEL_BINARY_ORIGIN;
   corp->set_origin(origin);
 
-  if (ctxt->cur_corpus_group_)
-    ctxt->cur_corpus_group_->add_corpus(ctxt->cur_corpus_);
-
   slurp_elf_info(ctxt, corp, status);
-  if (!is_linux_kernel
-      && ((status & elf_reader::STATUS_DEBUG_INFO_NOT_FOUND) |
-          (status & elf_reader::STATUS_NO_SYMBOLS_FOUND)))
+  if ((status & elf_reader::STATUS_NO_SYMBOLS_FOUND) ||
+      (!is_linux_kernel &&
+       (status & elf_reader::STATUS_DEBUG_INFO_NOT_FOUND)))
       return corp;
 
+  if (ctxt->cur_corpus_group_)
+    ctxt->cur_corpus_group_->add_corpus(ctxt->cur_corpus_);
+
   // Set the set of exported declaration that are defined.
   ctxt->exported_decls_builder
    (ctxt->cur_corpus_->get_exported_decls_builder().get());
@@ -1674,9 +1681,13 @@ read_corpus(read_context *ctxt, elf_reader::status &status)
     {
       if (ctxt->ctfa == NULL)
         {
-          std::string ctfa_filename;
-          if (find_ctfa_file(ctxt, ctfa_filename))
-            ctxt->ctfa = ctf_arc_open(ctfa_filename.c_str(), &errp);
+          std::string filename;
+          base_name(ctxt->filename, filename);
+
+          // locate vmlinux.ctfa only when reader is processing
+          // vmlinux file, i.e the main corpus in the group.
+          if (filename == "vmlinux" && find_ctfa_file(ctxt, filename))
+            ctxt->ctfa = ctf_arc_open(filename.c_str(), &errp);
         }
     }
   else
diff --git a/src/abg-tools-utils.cc b/src/abg-tools-utils.cc
index fe9ebc72..a23f08ea 100644
--- a/src/abg-tools-utils.cc
+++ b/src/abg-tools-utils.cc
@@ -1694,6 +1694,23 @@ file_is_kernel_debuginfo_package(const string& file_name, file_type file_type)
   return result;
 }
 
+/// Test if a directory contains a CTF archive.
+///
+/// @param directory the directory to consider.
+///
+/// @param archive_prefix the prefix of the archive file.
+///
+/// @return true iff @p directory contains a CTF archive file.
+bool
+dir_contains_ctf_archive(const string& directory,
+			 const string& archive_prefix)
+{
+  string ctf_archive = directory + "/" + archive_prefix + ".ctfa";
+  if (file_exists(ctf_archive))
+    return true;
+  return false;
+}
+
 /// The delete functor of a char buffer that has been created using
 /// malloc.
 struct malloced_char_star_deleter
@@ -2525,8 +2542,12 @@ get_binary_paths_from_kernel_dist(const string&	dist_root,
 /// @param t time to trace time spent in each step.
 ///
 /// @param env the environment to create the corpus_group in.
-static void
-maybe_load_vmlinux_dwarf_corpus(corpus::origin      origin,
+///
+/// @return the status of the loading.  If it's
+/// abigail::elf_reader::STATUS_UNKNOWN, then it means nothing was
+/// done, meaning the function got out early.
+static abigail::elf_reader::status
+maybe_load_vmlinux_dwarf_corpus(corpus::origin&     origin,
                                 corpus_group_sptr&  group,
                                 const string&       vmlinux,
                                 vector<string>&     modules,
@@ -2539,10 +2560,11 @@ maybe_load_vmlinux_dwarf_corpus(corpus::origin      origin,
                                 timer&              t,
                                 environment_sptr&   env)
 {
+  abigail::elf_reader::status status = abigail::elf_reader::STATUS_UNKNOWN;
+
   if (!(origin & corpus::DWARF_ORIGIN))
-    return;
+    return status;
 
-  abigail::elf_reader::status status = abigail::elf_reader::STATUS_OK;
   dwarf_reader::read_context_sptr ctxt;
   ctxt =
    dwarf_reader::create_read_context(vmlinux, di_roots, env.get(),
@@ -2569,6 +2591,7 @@ maybe_load_vmlinux_dwarf_corpus(corpus::origin      origin,
      << vmlinux << "' ...\n" << std::flush;
 
   // Read the vmlinux corpus and add it to the group.
+  status = abigail::elf_reader::STATUS_OK;
   t.start();
   read_and_add_corpus_to_group_from_elf(*ctxt, *group, status);
   t.stop();
@@ -2579,7 +2602,7 @@ maybe_load_vmlinux_dwarf_corpus(corpus::origin      origin,
      << t << "\n";
 
   if (group->is_empty())
-    return;
+    return status;
 
   // Now add the corpora of the modules to the corpus group.
   int total_nb_modules = modules.size();
@@ -2614,6 +2637,7 @@ maybe_load_vmlinux_dwarf_corpus(corpus::origin      origin,
          << "' reading DONE: "
          << t << "\n";
     }
+  return status;
 }
 
 /// If the @ref origin is CTF_ORIGIN it build a @ref corpus_group
@@ -2642,8 +2666,12 @@ maybe_load_vmlinux_dwarf_corpus(corpus::origin      origin,
 /// @param t time to trace time spent in each step.
 ///
 /// @param env the environment to create the corpus_group in.
+///
+/// @return the status of the loading.  If it's
+/// abigail::elf_reader::STATUS_UNKNOWN, then it means nothing was
+/// done, meaning the function got out early.
 #ifdef WITH_CTF
-static void
+static abigail::elf_reader::status
 maybe_load_vmlinux_ctf_corpus(corpus::origin	  origin,
                               corpus_group_sptr&  group,
                               const string&       vmlinux,
@@ -2654,10 +2682,11 @@ maybe_load_vmlinux_ctf_corpus(corpus::origin	  origin,
                               timer&              t,
                               environment_sptr&   env)
 {
+  abigail::elf_reader::status status = abigail::elf_reader::STATUS_UNKNOWN;
+
   if (!(origin & corpus::CTF_ORIGIN))
-    return;
+    return status;
 
-  abigail::elf_reader::status status = abigail::elf_reader::STATUS_OK;
   ctf_reader::read_context_sptr ctxt;
   ctxt = ctf_reader::create_read_context(vmlinux, di_roots, env.get());
   group.reset(new corpus_group(env.get(), root));
@@ -2668,6 +2697,7 @@ maybe_load_vmlinux_ctf_corpus(corpus::origin	  origin,
      << vmlinux << "' ...\n" << std::flush;
 
   // Read the vmlinux corpus and add it to the group.
+  status = abigail::elf_reader::STATUS_OK;
   t.start();
   read_and_add_corpus_to_group_from_elf(ctxt.get(), *group, status);
   t.stop();
@@ -2678,7 +2708,7 @@ maybe_load_vmlinux_ctf_corpus(corpus::origin	  origin,
      << t << "\n";
 
   if (group->is_empty())
-    return;
+    return status;
 
   // Now add the corpora of the modules to the corpus group.
   int total_nb_modules = modules.size();
@@ -2707,6 +2737,7 @@ maybe_load_vmlinux_ctf_corpus(corpus::origin	  origin,
          << "' reading DONE: "
          << t << "\n";
     }
+  return status;
 }
 #endif
 
@@ -2786,14 +2817,23 @@ build_corpus_group_from_kernel_dist_under(const string&	root,
       vector<char**> di_roots;
       di_roots.push_back(&di_root_ptr);
 
-      maybe_load_vmlinux_dwarf_corpus(origin, group, vmlinux,
-                                      modules, root, di_roots,
-                                      suppr_paths, kabi_wl_paths,
-                                      supprs, verbose, t, env);
+      abigail::elf_reader::status status =
+	maybe_load_vmlinux_dwarf_corpus(origin, group, vmlinux,
+					modules, root, di_roots,
+					suppr_paths, kabi_wl_paths,
+					supprs, verbose, t, env);
 #ifdef WITH_CTF
+      string vmlinux_basename;
+      base_name(vmlinux, vmlinux_basename);
+      if (origin == corpus::DWARF_ORIGIN
+	  && (status & abigail::elf_reader::STATUS_DEBUG_INFO_NOT_FOUND)
+	  && dir_contains_ctf_archive(root, vmlinux_basename))
+	  // Let's try to load the binary using the CTF archive!
+	origin |= corpus::CTF_ORIGIN;
+
       maybe_load_vmlinux_ctf_corpus(origin, group, vmlinux,
-                                    modules, root, di_roots,
-                                    verbose, t, env);
+				    modules, root, di_roots,
+				    verbose, t, env);
 #endif
     }
 
diff --git a/tests/data/test-diff-pkg-ctf/dirpkg-3-report-2.txt b/tests/data/test-diff-pkg-ctf/dirpkg-3-report-2.txt
index e69de29b..4938d221 100644
--- a/tests/data/test-diff-pkg-ctf/dirpkg-3-report-2.txt
+++ b/tests/data/test-diff-pkg-ctf/dirpkg-3-report-2.txt
@@ -0,0 +1,16 @@
+================ changes of 'libobj-v0.so'===============
+  Functions changes summary: 0 Removed, 1 Changed (1 filtered out), 0 Added functions
+  Variables changes summary: 0 Removed, 0 Changed, 0 Added variable
+
+  1 function with some indirect sub-type change:
+
+    [C] 'function void foo(S1*)' has some indirect sub-type changes:
+      parameter 1 of type 'S1*' has sub-type changes:
+        in pointed to type 'struct S1':
+          type size changed from 0 to 32 (in bits)
+          type alignment changed from 0 to 32
+          1 data member insertion:
+            'int mem2', at offset 0 (in bits)
+
+================ end of changes of 'libobj-v0.so'===============
+
diff --git a/tests/test-diff-pkg.cc b/tests/test-diff-pkg.cc
index e128ff63..8e510ca2 100644
--- a/tests/test-diff-pkg.cc
+++ b/tests/test-diff-pkg.cc
@@ -855,7 +855,7 @@ static InOutSpec in_out_specs[] =
   { // Just like the previous tests, but loc info is emitted.
     "data/test-diff-pkg-ctf/dirpkg-3-dir1",
     "data/test-diff-pkg-ctf/dirpkg-3-dir2",
-    "--no-default-suppression --no-abignore",
+    "--ctf --no-default-suppression --no-abignore",
     "data/test-diff-pkg-ctf/dirpkg-3.suppr",
     "",
     "",
diff --git a/tools/abidiff.cc b/tools/abidiff.cc
index e0bb35ac..0d9e59c2 100644
--- a/tools/abidiff.cc
+++ b/tools/abidiff.cc
@@ -47,6 +47,9 @@ using abigail::suppr::suppressions_type;
 using abigail::suppr::read_suppressions;
 using namespace abigail::dwarf_reader;
 using namespace abigail::elf_reader;
+using abigail::tools_utils::base_name;
+using abigail::tools_utils::dir_name;
+using abigail::tools_utils::dir_contains_ctf_archive;
 using abigail::tools_utils::emit_prefix;
 using abigail::tools_utils::check_file;
 using abigail::tools_utils::guess_file_type;
@@ -1205,6 +1208,36 @@ main(int argc, char* argv[])
                 set_suppressions(*ctxt, opts);
                 abigail::dwarf_reader::set_do_log(*ctxt, opts.do_log);
                 c1 = abigail::dwarf_reader::read_corpus_from_elf(*ctxt, c1_status);
+
+#ifdef WITH_CTF
+		if (// We were not instructed to use CTF ...
+		    !opts.use_ctf
+		    // ... and yet, no debug info was found ...
+		    && (c1_status & STATUS_DEBUG_INFO_NOT_FOUND)
+		    // ... but we found ELF symbols ...
+		    && !(c1_status & STATUS_NO_SYMBOLS_FOUND))
+		  {
+		    string basenam, dirnam;
+		    base_name(opts.file1, basenam);
+		    dir_name(opts.file1, dirnam);
+		    // ... the input file seems to contain CTF
+		    // archive, so let's try to see if the file
+		    // contains a CTF archive, who knows ...
+		    if (dir_contains_ctf_archive(dirnam, basenam))
+		      {
+			// The file does contain CTF debug information finally!
+			abigail::ctf_reader::read_context_sptr ctxt =
+			  abigail::ctf_reader::create_read_context
+			  (opts.file1,
+			   opts.prepared_di_root_paths1,
+			   env.get());
+			ABG_ASSERT(ctxt);
+
+			c1 = abigail::ctf_reader::read_corpus(ctxt.get(),
+							      c1_status);
+		      }
+		  }
+#endif
                 if (!c1
                     || (opts.fail_no_debug_info
                         && (c1_status & STATUS_ALT_DEBUG_INFO_NOT_FOUND)
@@ -1212,7 +1245,7 @@ main(int argc, char* argv[])
                   return handle_error(c1_status, ctxt.get(),
                                       argv[0], opts);
               }
-	  }
+          }
 	  break;
 	case abigail::tools_utils::FILE_TYPE_XML_CORPUS:
 	  {
@@ -1289,13 +1322,44 @@ main(int argc, char* argv[])
                 set_suppressions(*ctxt, opts);
 
                 c2 = abigail::dwarf_reader::read_corpus_from_elf(*ctxt, c2_status);
+
+#ifdef WITH_CTF
+		if (// We were not instructed to use CTF ...
+		    !opts.use_ctf
+		    // ... and yet, no debug info was found ...
+		    && (c2_status & STATUS_DEBUG_INFO_NOT_FOUND)
+		    // ... but we found ELF symbols ...
+		    && !(c2_status & STATUS_NO_SYMBOLS_FOUND))
+		  {
+		    string basenam, dirnam;
+		    base_name(opts.file2, basenam);
+		    dir_name(opts.file2, dirnam);
+		    // ... the input file seems to contain CTF
+		    // archive, so let's try to see if the file
+		    // contains a CTF archive, who knows ...
+		      if (dir_contains_ctf_archive(dirnam, basenam))
+		      {
+			// The file does contain CTF debug information finally!
+			abigail::ctf_reader::read_context_sptr ctxt =
+			  abigail::ctf_reader::create_read_context
+			  (opts.file2,
+			   opts.prepared_di_root_paths2,
+			   env.get());
+			ABG_ASSERT(ctxt);
+
+			c2 = abigail::ctf_reader::read_corpus(ctxt.get(),
+							      c2_status);
+		      }
+		  }
+#endif
+
                 if (!c2
                     || (opts.fail_no_debug_info
                         && (c2_status & STATUS_ALT_DEBUG_INFO_NOT_FOUND)
                         && (c2_status & STATUS_DEBUG_INFO_NOT_FOUND)))
                   return handle_error(c2_status, ctxt.get(), argv[0], opts);
               }
-	  }
+          }
 	  break;
 	case abigail::tools_utils::FILE_TYPE_XML_CORPUS:
 	  {
diff --git a/tools/abidw.cc b/tools/abidw.cc
index f38d6048..c68a30f4 100644
--- a/tools/abidw.cc
+++ b/tools/abidw.cc
@@ -41,6 +41,9 @@ using std::ofstream;
 using std::vector;
 using std::shared_ptr;
 using abg_compat::optional;
+using abigail::tools_utils::base_name;
+using abigail::tools_utils::dir_name;
+using abigail::tools_utils::dir_contains_ctf_archive;
 using abigail::tools_utils::emit_prefix;
 using abigail::tools_utils::temp_file;
 using abigail::tools_utils::temp_file_sptr;
@@ -557,16 +560,16 @@ load_corpus_and_write_abixml(char* argv[],
   if (opts.use_ctf)
     {
       abigail::ctf_reader::read_context_sptr ctxt
-        = abigail::ctf_reader::create_read_context(opts.in_file_path,
-                                                   opts.prepared_di_root_paths,
-                                                   env.get());
+	= abigail::ctf_reader::create_read_context(opts.in_file_path,
+						   opts.prepared_di_root_paths,
+						   env.get());
       assert (ctxt);
       t.start();
       corp = abigail::ctf_reader::read_corpus (ctxt, s);
       t.stop();
       if (opts.do_log)
-        emit_prefix(argv[0], cerr)
-          << "read corpus from elf file in: " << t << "\n";
+	emit_prefix(argv[0], cerr)
+	  << "read corpus from elf file in: " << t << "\n";
     }
   else
 #endif
@@ -616,7 +619,7 @@ load_corpus_and_write_abixml(char* argv[],
         }
 
       if (opts.exported_interfaces_only.has_value())
-	env->analyze_exported_interfaces_only(*opts.exported_interfaces_only);
+        env->analyze_exported_interfaces_only(*opts.exported_interfaces_only);
 
       t.start();
       corp = dwarf_reader::read_corpus_from_elf(ctxt, s);
@@ -632,6 +635,38 @@ load_corpus_and_write_abixml(char* argv[],
       if (opts.do_log)
         emit_prefix(argv[0], cerr)
           << "reset read context in: " << t << "\n";
+
+#ifdef WITH_CTF
+      if (// We were not instructed to use CTF ...
+	  !opts.use_ctf
+	  // ... and yet, no debug info was found ...
+	  && (s & abigail::elf_reader::STATUS_DEBUG_INFO_NOT_FOUND)
+	  // ... but we found ELF symbols ...
+	  && !(s & abigail::elf_reader::STATUS_NO_SYMBOLS_FOUND))
+	{
+	  string basenam, dirnam;
+	  base_name(opts.in_file_path, basenam);
+	  dir_name(opts.in_file_path, dirnam);
+	  // ... the input file seems to contain CTF
+	  // archive, so let's try to see if the file
+	  // contains a CTF archive, who knows ...
+	  if (dir_contains_ctf_archive(dirnam, basenam))
+	    {
+	      abigail::ctf_reader::read_context_sptr ctxt
+		= abigail::ctf_reader::create_read_context(opts.in_file_path,
+							   opts.prepared_di_root_paths,
+							   env.get());
+	      assert (ctxt);
+	      t.start();
+	      corp = abigail::ctf_reader::read_corpus (ctxt, s);
+	      t.stop();
+
+	      if (opts.do_log)
+		emit_prefix(argv[0], cerr)
+		  << "read CTF corpus from elf file in:" << t << "\n";
+	    }
+	}
+#endif
     }
 
   // If we couldn't create a corpus, emit some (hopefully) useful
@@ -834,7 +869,7 @@ load_kernel_corpus_group_and_write_abixml(char* argv[],
 
   global_timer.start();
   t.start();
-corpus::origin origin =
+  corpus::origin origin =
 #ifdef WITH_CTF
     opts.use_ctf ? corpus::CTF_ORIGIN :
 #endif
diff --git a/tools/abipkgdiff.cc b/tools/abipkgdiff.cc
index 656d5882..e7bb5c37 100644
--- a/tools/abipkgdiff.cc
+++ b/tools/abipkgdiff.cc
@@ -127,6 +127,7 @@ using abigail::tools_utils::make_path_absolute;
 using abigail::tools_utils::base_name;
 using abigail::tools_utils::get_rpm_arch;
 using abigail::tools_utils::file_is_kernel_package;
+using abigail::tools_utils::dir_contains_ctf_archive;
 using abigail::tools_utils::gen_suppr_spec_from_headers;
 using abigail::tools_utils::get_default_system_suppression_file_path;
 using abigail::tools_utils::get_default_user_suppression_file_path;
@@ -1346,6 +1347,34 @@ compare(const elf_file& elf1,
           add_read_context_suppressions(*ctxt_dwarf, opts.kabi_suppressions);
 
         corpus1 = read_corpus_from_elf(*ctxt_dwarf, c1_status);
+
+#ifdef WITH_CTF
+	if (// We were not instructed to use CTF ...
+	    !opts.use_ctf
+	    // ... and yet, no debug info was found ...
+	    && (c1_status & abigail::elf_reader::STATUS_DEBUG_INFO_NOT_FOUND)
+	    // ... but we found ELF symbols ...
+	    && !(c1_status & abigail::elf_reader::STATUS_NO_SYMBOLS_FOUND))
+	  {
+	    string basenam, dirnam;
+	    base_name(elf1.path, basenam);
+	    dir_name(elf1.path, dirnam);
+	    // ... the input file seems to contain CTF
+	    // archive, so let's try to see if the file
+	    // contains a CTF archive, who knows ...
+	    if (dir_contains_ctf_archive(dirnam, basenam))
+	      {
+		// The file does contain CTF debug information
+		// finally!
+		ctxt_ctf = abigail::ctf_reader::create_read_context(elf1.path,
+								    di_dirs1,
+								    env.get());
+		ABG_ASSERT(ctxt_ctf);
+		corpus1 = abigail::ctf_reader::read_corpus(ctxt_ctf.get(),
+							   c1_status);
+	      }
+	  }
+#endif
       }
 
     bool bail_out = false;
@@ -1451,6 +1480,34 @@ compare(const elf_file& elf1,
           add_read_context_suppressions(*ctxt_dwarf, opts.kabi_suppressions);
 
         corpus2 = read_corpus_from_elf(*ctxt_dwarf, c2_status);
+
+#ifdef WITH_CTF
+	if (// We were not instructed to use CTF ...
+	    !opts.use_ctf
+	    // ... and yet, no debug info was found ...
+	    && (c2_status & abigail::elf_reader::STATUS_DEBUG_INFO_NOT_FOUND)
+	    // ... but we found ELF symbols ...
+	    && !(c2_status & abigail::elf_reader::STATUS_NO_SYMBOLS_FOUND))
+	  {
+	    string basenam, dirnam;
+	    base_name(elf2.path, basenam);
+	    dir_name(elf2.path, dirnam);
+	    // ... the input file seems to contain CTF
+	    // archive, so let's try to see if the file
+	    // contains a CTF archive, who knows ...
+	    if (dir_contains_ctf_archive(dirnam, basenam))
+	      {
+		// The file does contain CTF debug information
+		// finally!
+		ctxt_ctf = abigail::ctf_reader::create_read_context(elf2.path,
+								    di_dirs2,
+								    env.get());
+		ABG_ASSERT(ctxt_ctf);
+		corpus2 = abigail::ctf_reader::read_corpus(ctxt_ctf.get(),
+							   c2_status);
+	      }
+	  }
+#endif
       }
 
     bool bail_out = false;
@@ -1612,17 +1669,44 @@ compare_to_self(const elf_file& elf,
 							    di_dirs,
                                                             env.get());
         ABG_ASSERT(ctxt_ctf);
-        corp = abigail::ctf_reader::read_corpus(ctxt_ctf.get(),
-                                                   c_status);
+        corp = abigail::ctf_reader::read_corpus(ctxt_ctf.get(), c_status);
       }
     else
 #endif
       {
         ctxt_dwarf =
-         create_read_context(elf.path, di_dirs, env.get(),
-                             /*read_all_types=*/opts.show_all_types);
+	  create_read_context(elf.path, di_dirs, env.get(),
+			      /*read_all_types=*/opts.show_all_types);
 
         corp = read_corpus_from_elf(*ctxt_dwarf, c_status);
+
+#ifdef WITH_CTF
+	if (// We were not instructed to use CTF ...
+	    !opts.use_ctf
+	    // ... and yet, no debug info was found ...
+	    && (c_status & abigail::elf_reader::STATUS_DEBUG_INFO_NOT_FOUND)
+	    // ... but we found ELF symbols ...
+	    && !(c_status & abigail::elf_reader::STATUS_NO_SYMBOLS_FOUND))
+	  {
+	    string basenam, dirnam;
+	    base_name(elf.path, basenam);
+	    dir_name(elf.path, dirnam);
+	    // ... the input file seems to contain CTF
+	    // archive, so let's try to see if the file
+	    // contains a CTF archive, who knows ...
+	    if (dir_contains_ctf_archive(dirnam, basenam))
+	      {
+		// The file does contain CTF debug information
+		// finally!
+		ctxt_ctf = abigail::ctf_reader::create_read_context(elf.path,
+								    di_dirs,
+								    env.get());
+		ABG_ASSERT(ctxt_ctf);
+		corp = abigail::ctf_reader::read_corpus(ctxt_ctf.get(),
+							c_status);
+	      }
+	  }
+#endif
       }
 
     if (!(c_status & abigail::elf_reader::STATUS_OK))
