[sanitizer] Include inlined frames into __sanitizer_symbolize_pc output

[vitalybuka]

Summary

Behavior for existing used is not changing as the first line is going
to be the same, and it was invalid to try to read more lines.

New clients can read until they get empty string.

[vitalybuka]

documentation

[vitalybuka]

typo

[eugenis]

compiler-rt/include/sanitizer/common_interface_defs.h

127 ↗

(On Diff #167826)

Mention that the frames are printed in the order from most-inlined to least-inlined.

129 ↗

(On Diff #167826)

typo: inlined

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cc

126 ↗

(On Diff #167826)

what does this condition do?

[vitalybuka]

Updated doc

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cc

126 ↗

(On Diff #167826)

you can provide weird "fmt" which will result in empty strings.
Having that empty string is terminator we'd like to avoid them in the middle.

[eugenis]

LGTM

include/sanitizer/common_interface_defs.h

#endif
   const void *__sanitizer_contiguous_container_find_bad_address(
       const void *beg, const void *mid, const void *end);
 
   // Print the stack trace leading to this call. Useful for debugging user code.
   void __sanitizer_print_stack_trace(void);
 
   // Symbolizes the supplied 'pc' using the format string 'fmt'.
   // Outputs at most 'out_buf_size' bytes into 'out_buf'.
+  // If 'out_buf' is not empty then output is zero or more non empty C strings
+  // followed by single empty C string. Multiple strings can be returned if PC
+  // corresponds to inlined function. Inlined frames are printed in the order
+  // from "most-inlined" to the "least-inlined", so the last frame should be the
+  // not inlined function.
+  // Inlined frames can be removed with 'symbolize_inline_frames=0'.
   // The format syntax is described in
   // lib/sanitizer_common/sanitizer_stacktrace_printer.h.
   void __sanitizer_symbolize_pc(void *pc, const char *fmt, char *out_buf,
                                 size_t out_buf_size);
   // Same as __sanitizer_symbolize_pc, but for data section (i.e. globals).
   void __sanitizer_symbolize_global(void *data_ptr, const char *fmt,
                                     char *out_buf, size_t out_buf_size);
 

lib/sanitizer_common/sanitizer_stacktrace_libcdep.cc

void __sanitizer_symbolize_pc(uptr pc, const char *fmt, char *out_buf,
   pc = StackTrace::GetPreviousInstructionPc(pc);
   SymbolizedStack *frame = Symbolizer::GetOrInit()->SymbolizePC(pc);
   if (!frame) {
     internal_strncpy(out_buf, "<can't symbolize>", out_buf_size);
     out_buf[out_buf_size - 1] = 0;
     return;
   }
   InternalScopedString frame_desc(GetPageSizeCached());
-  RenderFrame(&frame_desc, fmt, 0, frame->info,
+  uptr frame_num = 0;
+  // Reserve one byte for the final 0.
+  char *out_end = out_buf + out_buf_size - 1;
+  for (SymbolizedStack *cur = frame; cur && out_buf < out_end;
+       cur = cur->next) {
+    frame_desc.clear();
+    RenderFrame(&frame_desc, fmt, frame_num++, cur->info,
                 common_flags()->symbolize_vs_style,
                 common_flags()->strip_path_prefix);
-  internal_strncpy(out_buf, frame_desc.data(), out_buf_size);
-  out_buf[out_buf_size - 1] = 0;
+    if (!frame_desc.length())
+      continue;
+    // Reserve one byte for the terminating 0.
+    uptr n = out_end - out_buf - 1;
+    internal_strncpy(out_buf, frame_desc.data(), n);
+    out_buf += __sanitizer::Min<uptr>(n, frame_desc.length());
+    *out_buf++ = 0;
+  }
+  CHECK(out_buf <= out_end);
+  *out_buf = 0;
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __sanitizer_symbolize_global(uptr data_addr, const char *fmt,
                                   char *out_buf, uptr out_buf_size) {
   if (!out_buf_size) return;
   out_buf[0] = 0;
   DataInfo DI;

test/sanitizer_common/TestCases/symbolize_pc_inline.cc

+// RUN: %clangxx -O3  %s -o %t
+// RUN: %env_tool_opts=strip_path_prefix=/TestCases/ %run %t 2>&1 | FileCheck %s
+// RUN: %env_tool_opts=strip_path_prefix=/TestCases/:symbolize_inline_frames=0 \
+// RUN:   %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK-NOINLINE
+
+#include <sanitizer/common_interface_defs.h>
+#include <stdio.h>
+#include <string.h>
+
+char buffer[10000];
+
+__attribute__((noinline)) static void Symbolize() {
+  __sanitizer_symbolize_pc(__builtin_return_address(0), "%p %F %L", buffer,
+                           sizeof(buffer));
+  for (char *p = buffer; strlen(p); p += strlen(p) + 1)
+    printf("%s\n", p);
+}
+
+// CHECK-NOINLINE: {{0x[0-9a-f]+}} in main symbolize_pc_inline.cc:[[@LINE+2]]
+// CHECK: [[ADDR:0x[0-9a-f]+]] in C2 symbolize_pc_inline.cc:[[@LINE+1]]
+static inline void C2() { Symbolize(); }
+
+// CHECK: [[ADDR]] in C3 symbolize_pc_inline.cc:[[@LINE+1]]
+static inline void C3() { C2(); }
+
+// CHECK: [[ADDR]] in C4 symbolize_pc_inline.cc:[[@LINE+1]]
+static inline void C4() { C3(); }
+
+// CHECK: [[ADDR]] in main symbolize_pc_inline.cc:[[@LINE+1]]
+int main() { C4(); }