Fix asan and tsan tests

Signed-off-by: Dom Del Nano <[email protected]>

Author: ddelnano

src/stirling/obj_tools/dwarf_reader.cc

@@ -92,28 +92,30 @@ StatusOr<std::unique_ptr<DwarfReader>> DwarfReader::CreateWithoutIndexing(
   auto dwarf_reader = std::unique_ptr<DwarfReader>(
       new DwarfReader(std::move(buffer), DWARFContext::create(*obj_file)));
 
-  PX_RETURN_IF_ERROR(dwarf_reader->DetectSourceLanguage());
-
   return dwarf_reader;
 }
 
 StatusOr<std::unique_ptr<DwarfReader>> DwarfReader::CreateIndexingAll(
     const std::filesystem::path& path) {
   PX_ASSIGN_OR_RETURN(auto dwarf_reader, CreateWithoutIndexing(path));
   dwarf_reader->IndexDIEs(std::nullopt);
+  PX_RETURN_IF_ERROR(dwarf_reader->DetectSourceLanguage());
   return dwarf_reader;
 }
 
 StatusOr<std::unique_ptr<DwarfReader>> DwarfReader::CreateWithSelectiveIndexing(
     const std::filesystem::path& path, const std::vector<SymbolSearchPattern>& symbol_patterns) {
   PX_ASSIGN_OR_RETURN(auto dwarf_reader, CreateWithoutIndexing(path));
   dwarf_reader->IndexDIEs(symbol_patterns);
+  PX_RETURN_IF_ERROR(dwarf_reader->DetectSourceLanguage());
   return dwarf_reader;
 }
 
 DwarfReader::DwarfReader(std::unique_ptr<llvm::MemoryBuffer> buffer,
                          std::unique_ptr<llvm::DWARFContext> dwarf_context)
-    : memory_buffer_(std::move(buffer)), dwarf_context_(std::move(dwarf_context)) {
+    : is_multi_lang_(std::nullopt),
+      memory_buffer_(std::move(buffer)),
+      dwarf_context_(std::move(dwarf_context)) {
   // Only very first call will actually perform initialization.
   InitLLVMOnce();
 }
@@ -154,31 +156,60 @@ bool IsNamespace(llvm::dwarf::Tag tag) { return tag == llvm::dwarf::DW_TAG_names
 
 }  // namespace
 
+StatusOr<std::pair<llvm::dwarf::SourceLanguage, std::string>>
+DwarfReader::DetectSourceLanguageFromCUDIE(const llvm::DWARFDie& unit_die) {
+  if (unit_die.getTag() != llvm::dwarf::DW_TAG_compile_unit) {
+    // Skip over DW_TAG_partial_unit, and potentially other tags.
+    return error::NotFound("Expected DW_TAG_compile_unit, but got DW_TAG=$0 for unit DIE: $1",
+                           magic_enum::enum_name(unit_die.getTag()), Dump(unit_die));
+  }
+  const DWARFFormValue& producer_attr =
+      GetAttribute(unit_die, llvm::dwarf::DW_AT_producer).ValueOr({});
+  auto s = producer_attr.getAsCString();
+  std::string compiler;
+#if LLVM_VERSION_MAJOR >= 14
+  if (!s.takeError()) {
+    compiler = s.get();
+  }
+#else
+  compiler = s.getValueOr("");
+#endif
+  PX_ASSIGN_OR_RETURN(const DWARFFormValue& lang_attr,
+                      GetAttribute(unit_die, llvm::dwarf::DW_AT_language));
+  auto source_language =
+      static_cast<llvm::dwarf::SourceLanguage>(lang_attr.getAsUnsignedConstant().getValue());
+  return std::make_pair(source_language, compiler);
+}
+
 Status DwarfReader::DetectSourceLanguage() {
+  is_multi_lang_ = false;
+  std::optional<llvm::dwarf::SourceLanguage> prev_source_language;
+  std::optional<std::string> prev_compiler;
   for (size_t i = 0; i < dwarf_context_->getNumCompileUnits(); ++i) {
     const auto& unit_die = dwarf_context_->getUnitAtIndex(i)->getUnitDIE();
-    if (unit_die.getTag() != llvm::dwarf::DW_TAG_compile_unit) {
-      // Skip over DW_TAG_partial_unit, and potentially other tags.
+    auto lang_s = DetectSourceLanguageFromCUDIE(unit_die);
+    if (!lang_s.ok()) {
       continue;
     }
-
-    PX_ASSIGN_OR(const DWARFFormValue& lang_attr,
-                 GetAttribute(unit_die, llvm::dwarf::DW_AT_language), continue);
-    source_language_ =
-        static_cast<llvm::dwarf::SourceLanguage>(lang_attr.getAsUnsignedConstant().getValue());
-
-    const DWARFFormValue& producer_attr =
-        GetAttribute(unit_die, llvm::dwarf::DW_AT_producer).ValueOr({});
-
-    auto s = producer_attr.getAsCString();
-#if LLVM_VERSION_MAJOR >= 14
-    if (!s.takeError()) {
-      compiler_ = s.get();
+    auto p = lang_s.ValueOrDie();
+    auto source_language = p.first;
+    auto& compiler = p.second;
+
+    if (!prev_source_language.has_value()) {
+      prev_source_language = source_language;
+    } else if (prev_source_language.has_value() &&
+               prev_source_language.value() != source_language) {
+      is_multi_lang_ = true;
     }
-#else
-    compiler_ = s.getValueOr("");
-#endif
 
+    if (!prev_compiler.has_value()) {
+      prev_compiler = compiler;
+    } else if (prev_compiler.has_value() && prev_compiler.value() != compiler) {
+      is_multi_lang_ = true;
+    }
+  }
+  if (prev_source_language.has_value() && prev_compiler.has_value()) {
+    source_language_ = prev_source_language.value();
     return Status::OK();
   }
   return error::Internal(
@@ -923,16 +954,20 @@ StatusOr<std::map<std::string, ArgInfo>> DwarfReader::GetFunctionArgInfo(
   // but DW_AT_location has been found to be blank in some cases, making it unreliable.
   // Instead, we use a FunctionArgTracker that tries to reverse engineer the calling convention.
 
-  ABI abi = LanguageToABI(source_language_, compiler_);
+  PX_ASSIGN_OR_RETURN(const DWARFDie& function_die,
+                      GetMatchingDIE(function_symbol_name, llvm::dwarf::DW_TAG_subprogram));
+  // Certain binaries can have DW_TAG_compile_units with different source languages. When compiling
+  // programs with ASAN/TSAN enabled this is common.
+  llvm::DWARFUnit* cu = function_die.getDwarfUnit();
+  llvm::DWARFDie unit_die = cu->getUnitDIE();
+  PX_ASSIGN_OR_RETURN(auto p, DetectSourceLanguageFromCUDIE(unit_die));
+  ABI abi = LanguageToABI(p.first, p.second);
   if (abi == ABI::kUnknown) {
     return error::Unimplemented("Unable to determine ABI from language: $0",
                                 magic_enum::enum_name(source_language_));
   }
   std::unique_ptr<ABICallingConventionModel> arg_tracker = ABICallingConventionModel::Create(abi);
 
-  PX_ASSIGN_OR_RETURN(const DWARFDie& function_die,
-                      GetMatchingDIE(function_symbol_name, llvm::dwarf::DW_TAG_subprogram));
-
   // If function has a return value, process that first.
   // This is important, because in some ABIs (e.g. SystemV ABI),
   // if the return value is not able to be passed back in the available registers,
@@ -968,7 +1003,7 @@ StatusOr<std::map<std::string, ArgInfo>> DwarfReader::GetFunctionArgInfo(
     PX_ASSIGN_OR_RETURN(const DWARFDie type_die, GetTypeDie(die));
     PX_ASSIGN_OR_RETURN(arg.type_info, GetTypeInfo(die, type_die));
 
-    if (source_language_ == llvm::dwarf::DW_LANG_Go) {
+    if (p.first == llvm::dwarf::DW_LANG_Go) {
       arg.retarg = IsGolangRetArg(die).ValueOr(false);
     }
 

src/stirling/obj_tools/dwarf_reader.h

@@ -178,6 +178,12 @@ class DwarfReader {
   StatusOr<llvm::DWARFDie> GetMatchingDIE(std::string_view name,
                                           std::optional<llvm::dwarf::Tag> type = {});
 
+  /**
+   * Detects the source language and compiler from a DW_TAG_compile_unit's attributes.
+   */
+  StatusOr<std::pair<llvm::dwarf::SourceLanguage, std::string>> DetectSourceLanguageFromCUDIE(
+      const llvm::DWARFDie& die);
+
   /**
    * Return the size of a struct.
    */
@@ -291,8 +297,18 @@ class DwarfReader {
 
   bool IsValid() const { return dwarf_context_->getNumCompileUnits() != 0; }
 
-  const llvm::dwarf::SourceLanguage& source_language() const { return source_language_; }
-  const std::string& compiler() const { return compiler_; }
+  StatusOr<llvm::dwarf::SourceLanguage> source_language() const {
+    if (!is_multi_lang_.has_value()) {
+      return error::Internal(
+          "source_language() called before the source language was detected. "
+          "Call DetectSourceLanguage() first.");
+    } else if (is_multi_lang_.value()) {
+      return error::Internal(
+          "source_language() called on a multi-language DWARF file. "
+          "Use GetMatchingDIEs() to find the source language for a specific DIE.");
+    }
+    return source_language_;
+  }
 
  private:
   DwarfReader(std::unique_ptr<llvm::MemoryBuffer> buffer,
@@ -320,8 +336,7 @@ class DwarfReader {
   // Records the source language of the DWARF information.
   llvm::dwarf::SourceLanguage source_language_;
 
-  // Records the name of the compiler that produces this file.
-  std::string compiler_;
+  std::optional<bool> is_multi_lang_;
 
   std::unique_ptr<llvm::MemoryBuffer> memory_buffer_;
   std::unique_ptr<llvm::DWARFContext> dwarf_context_;

src/stirling/obj_tools/dwarf_reader_test.cc

@@ -72,15 +72,18 @@ class CppDwarfReaderTest : public ::testing::TestWithParam<DwarfReaderTestParam>
   void SetUp() override {
     DwarfReaderTestParam p = GetParam();
     ASSERT_OK_AND_ASSIGN(dwarf_reader, CreateDwarfReader(p.binary_path, p.index));
+    indexed = p.index;
   }
   std::unique_ptr<DwarfReader> dwarf_reader;
+  bool indexed;
 };
 
 class GolangDwarfReaderTest : public ::testing::TestWithParam<DwarfReaderTestParam> {
  protected:
   void SetUp() override {
     DwarfReaderTestParam p = GetParam();
     ASSERT_OK_AND_ASSIGN(dwarf_reader, CreateDwarfReader(p.binary_path, p.index));
+    indexed = p.index;
   }
 
   StatusOr<SemVer> GetGoVersion() const {
@@ -97,6 +100,7 @@ class GolangDwarfReaderTest : public ::testing::TestWithParam<DwarfReaderTestPar
   }
 
   std::unique_ptr<DwarfReader> dwarf_reader;
+  bool indexed;
 };
 
 class GolangDwarfReaderIndexTest : public ::testing::TestWithParam<bool> {
@@ -110,23 +114,54 @@ TEST_P(CppDwarfReaderTest, NonExistentPath) {
 
 TEST_P(CppDwarfReaderTest, SourceLanguage) {
   {
-    // We use C++17, but the dwarf shows 14.
-    EXPECT_EQ(dwarf_reader->source_language(), llvm::dwarf::DW_LANG_C_plus_plus_14);
-    EXPECT_THAT(dwarf_reader->compiler(), ::testing::HasSubstr("clang"));
+    // Indexed DwarfReader's have source_language() populated, while non-indexed ones do not.
+    auto source_lang_s = dwarf_reader->source_language();
+    if (indexed) {
+      // We use C++17, but the dwarf shows 14.
+      EXPECT_EQ(source_lang_s.ValueOrDie(), llvm::dwarf::DW_LANG_C_plus_plus_14);
+    } else {
+      EXPECT_TRUE(!source_lang_s.ok());
+    }
+
+    // Check that source language detect for individual DIEs works.
+    ASSERT_OK_AND_ASSIGN(
+        auto die, dwarf_reader->GetMatchingDIE("CanYouFindThis", llvm::dwarf::DW_TAG_subprogram));
+    llvm::DWARFUnit* cu = die.getDwarfUnit();
+    llvm::DWARFDie unit_die = cu->getUnitDIE();
+    ASSERT_OK_AND_ASSIGN(auto p, dwarf_reader->DetectSourceLanguageFromCUDIE(unit_die));
+    EXPECT_EQ(p.first, llvm::dwarf::DW_LANG_C_plus_plus_14);
+    EXPECT_THAT(p.second, ::testing::HasSubstr("clang"));
   }
 }
 
 TEST_P(GolangDwarfReaderTest, SourceLanguage) {
   {
-    EXPECT_EQ(dwarf_reader->source_language(), llvm::dwarf::DW_LANG_Go);
-    EXPECT_THAT(dwarf_reader->compiler(), ::testing::HasSubstr("go"));
+    auto source_lang_s = dwarf_reader->source_language();
+    // Indexed DwarfReader's have source_language() populated, while non-indexed ones do not.
+    if (indexed) {
+      if (source_lang_s.ok()) {
+        EXPECT_EQ(source_lang_s.ValueOrDie(), llvm::dwarf::DW_LANG_Go);
+      } else {
+        ASSERT_THAT(std::string(source_lang_s.msg()),
+                    ::testing::HasSubstr("multi-language DWARF file"));
+      }
+    } else {
+      EXPECT_TRUE(!source_lang_s.ok());
+    }
 
+    // Check that source language detect for individual DIEs works.
     ASSERT_OK_AND_ASSIGN(const bool uses_regabi, UsesRegABI());
-
+    ASSERT_OK_AND_ASSIGN(auto die, dwarf_reader->GetMatchingDIE("main.(*Vertex).Scale",
+                                                                llvm::dwarf::DW_TAG_subprogram));
+    llvm::DWARFUnit* cu = die.getDwarfUnit();
+    llvm::DWARFDie unit_die = cu->getUnitDIE();
+    ASSERT_OK_AND_ASSIGN(auto p, dwarf_reader->DetectSourceLanguageFromCUDIE(unit_die));
     if (uses_regabi) {
-      EXPECT_THAT(dwarf_reader->compiler(), ::testing::HasSubstr("regabi"));
+      EXPECT_EQ(p.first, llvm::dwarf::DW_LANG_Go);
+      EXPECT_THAT(p.second, ::testing::HasSubstr("regabi"));
     } else {
-      EXPECT_THAT(dwarf_reader->compiler(), ::testing::Not(::testing::HasSubstr("regabi")));
+      EXPECT_EQ(p.first, llvm::dwarf::DW_LANG_Go);
+      EXPECT_THAT(p.second, ::testing::Not(::testing::HasSubstr("regabi")));
     }
   }
 }

src/stirling/source_connectors/dynamic_tracer/dynamic_tracing/autogen.cc

@@ -61,22 +61,33 @@ void DetectSourceLanguage(obj_tools::ElfReader* elf_reader, obj_tools::DwarfRead
 
   // Primary detection mechanism is DWARF info, when available.
   if (dwarf_reader != nullptr) {
-    detected_language = TransformSourceLanguage(dwarf_reader->source_language())
-                            .ConsumeValueOr(ir::shared::Language::LANG_UNKNOWN);
+    // It's possible for DWARF to have DW_TAG_compile_unit's from multiple languages.
+    // We currently only support binaries with a single language, so we
+    // assert that this is the case.
+    auto source_lang_s = dwarf_reader->source_language();
+    if (source_lang_s.ok()) {
+      auto source_lang = source_lang_s.ValueOrDie();
+      detected_language =
+          TransformSourceLanguage(source_lang).ConsumeValueOr(ir::shared::Language::LANG_UNKNOWN);
+      LOG(INFO) << absl::Substitute("Using language $0 for object $1 and others",
+                                    magic_enum::enum_name(source_lang),
+                                    input_program->deployment_spec().path_list().paths(0));
+
+    } else {
+      detected_language = ir::shared::Language::LANG_UNKNOWN;
+    }
   } else {
     // Back-up detection policy looks for certain language-specific symbols
     if (IsGoExecutable(elf_reader)) {
       detected_language = ir::shared::Language::GOLANG;
+      LOG(INFO) << absl::Substitute("Using language GOLANG for object $1 and others",
+                                    input_program->deployment_spec().path_list().paths(0));
     }
 
     // TODO(oazizi): Make this stronger by adding more elf-based tests.
   }
 
   if (detected_language != ir::shared::Language::LANG_UNKNOWN) {
-    LOG(INFO) << absl::Substitute("Using language $0 for object $1 and others",
-                                  magic_enum::enum_name(dwarf_reader->source_language()),
-                                  input_program->deployment_spec().path_list().paths(0));
-
     // Since we only support tracing of a single object, all tracepoints have the same language.
     for (auto& tracepoint : *input_program->mutable_tracepoints()) {
       tracepoint.mutable_program()->set_language(detected_language);

src/stirling/source_connectors/socket_tracer/bcc_bpf/go_http2_trace.c

@@ -161,8 +161,7 @@ static __inline int32_t get_fd_from_http_http2Framer(const void* framer_ptr,
   }
 
   struct go_interface inner_intf;
-  BPF_PROBE_READ_VAR(inner_intf,
-                     io_writer_interface.ptr + inner_intf_offset);
+  BPF_PROBE_READ_VAR(inner_intf, io_writer_interface.ptr + inner_intf_offset);
 
   if (conn_intf) {
     return get_fd_from_conn_intf(inner_intf);