add code format

Author: gaohaoyuan

backtrace/include/Config.h

@@ -3,11 +3,11 @@
 #include <stdint.h>
 #include <cstddef>
 
-constexpr uint64_t BACKTRACE = 0x1; // 记录堆栈
-constexpr uint64_t TRACK_ALLOCS = 0x2; // 记录内存申请动作
-constexpr uint64_t BACKTRACE_SPECIFIC_SIZES = 0x4; // 记录特定大小的内存申请
-constexpr uint64_t RECORD_MEMORY_PEAK = 0x8; // 记录内存峰值
-constexpr uint64_t DUMP_ON_SINGAL = 0x80; // 记录内存峰值
+constexpr uint64_t BACKTRACE = 0x1;                 // 记录堆栈
+constexpr uint64_t TRACK_ALLOCS = 0x2;              // 记录内存申请动作
+constexpr uint64_t BACKTRACE_SPECIFIC_SIZES = 0x4;  // 记录特定大小的内存申请
+constexpr uint64_t RECORD_MEMORY_PEAK = 0x8;        // 记录内存峰值
+constexpr uint64_t DUMP_ON_SINGAL = 0x80;           // 记录内存峰值
 
 class Config {
 public:
@@ -27,7 +27,6 @@ class Config {
     size_t backtrace_dump_peak_val() const { return backtrace_dump_peak_val_; }
 
 private:
-
     int backtrace_dump_signal_ = 0;
 
     size_t backtrace_frames_ = 0;

backtrace/include/PointerData.h

@@ -1,56 +1,58 @@
 #pragma once
 
-#include <stdint.h>
 #include <fcntl.h>
+#include <stdint.h>
 
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
 #include <memory>
-#include <vector>
-#include <unordered_map>
 #include <mutex>
+#include <unordered_map>
+#include <vector>
 
 #include <bionic/macros.h>
 #include <unwindstack/Unwinder.h>
 
 #include "Config.h"
 
-enum MemType{ HOST, MMAP, DMA };
+enum MemType { HOST, MMAP, DMA };
 
 struct FrameKeyType {
-  size_t num_frames;
-  uintptr_t* frames;
-
-  bool operator==(const FrameKeyType& comp) const {
-    if (num_frames != comp.num_frames) return false;
-    for (size_t i = 0; i < num_frames; i++) {
-      if (frames[i] != comp.frames[i]) {
-        return false;
-      }
+    size_t num_frames;
+    uintptr_t* frames;
+
+    bool operator==(const FrameKeyType& comp) const {
+        if (num_frames != comp.num_frames)
+            return false;
+        for (size_t i = 0; i < num_frames; i++) {
+            if (frames[i] != comp.frames[i]) {
+                return false;
+            }
+        }
+        return true;
     }
-    return true;
-  }
 };
 
 // 新增 hash 算法
 namespace std {
-template <> struct hash<FrameKeyType> {
-  std::size_t operator()(const FrameKeyType& key) const {
-    std::size_t cur_hash = key.frames[0];
-    // Limit the number of frames to speed up hashing.
-    size_t max_frames = (key.num_frames > 5) ? 5 : key.num_frames;
-    for (size_t i = 1; i < max_frames; i++) {
-      cur_hash ^= key.frames[i];
+template <>
+struct hash<FrameKeyType> {
+    std::size_t operator()(const FrameKeyType& key) const {
+        std::size_t cur_hash = key.frames[0];
+        // Limit the number of frames to speed up hashing.
+        size_t max_frames = (key.num_frames > 5) ? 5 : key.num_frames;
+        for (size_t i = 1; i < max_frames; i++) {
+            cur_hash ^= key.frames[i];
+        }
+        return cur_hash;
     }
-    return cur_hash;
-  }
 };
 };  // namespace std
 
 struct FrameInfoType {
-  size_t references = 0;
-  std::vector<uintptr_t> frames;
+    size_t references = 0;
+    std::vector<uintptr_t> frames;
 };
 
 // 新增 timeval 比较函数
@@ -62,64 +64,67 @@ inline bool operator<(const timeval& lhs, const timeval& rhs) {
 }
 
 struct PointerInfoType {
-  size_t size;
-  size_t hash_index;
-  MemType mem_type;
-  timeval alloc_time;
-  size_t RealSize() const { return size & ~(1U << 31); }
-  static size_t MaxSize() { return (1U << 31) - 1; }
+    size_t size;
+    size_t hash_index;
+    MemType mem_type;
+    timeval alloc_time;
+    size_t RealSize() const { return size & ~(1U << 31); }
+    static size_t MaxSize() { return (1U << 31) - 1; }
 };
 
 struct ListInfoType {
-  uintptr_t pointer;
-  size_t num_allocations;
-  size_t size;
-  MemType mem_type;
-  FrameInfoType* frame_info;
-  std::shared_ptr<std::vector<unwindstack::FrameData>> backtrace_info;
-  timeval alloc_time;
+    uintptr_t pointer;
+    size_t num_allocations;
+    size_t size;
+    MemType mem_type;
+    FrameInfoType* frame_info;
+    std::shared_ptr<std::vector<unwindstack::FrameData>> backtrace_info;
+    timeval alloc_time;
 };
 using Pred = std::function<bool(const ListInfoType&, const ListInfoType&)>;
 
 class PointerData {
 public:
-  PointerData() = default;
-  virtual ~PointerData() = default;
+    PointerData() = default;
+    virtual ~PointerData() = default;
 
-  bool Initialize(const Config& config);
+    bool Initialize(const Config& config);
 
-  size_t AddBacktrace(size_t num_frames, size_t size_bytes);
-  void RemoveBacktrace(size_t hash_index);
+    size_t AddBacktrace(size_t num_frames, size_t size_bytes);
+    void RemoveBacktrace(size_t hash_index);
 
-  void Add(uintptr_t pointer, size_t size, MemType type);
-  void AddHost(const void* ptr, size_t pointer_size, MemType type = HOST);
-  void AddDMA(const uint32_t ptr, size_t pointer_size, MemType type = DMA);
-  void Remove(uintptr_t pointer, bool is_dma);
-  void RemoveHost(const void* ptr);
-  void RemoveDMA(const uint32_t ptr);
+    void Add(uintptr_t pointer, size_t size, MemType type);
+    void AddHost(const void* ptr, size_t pointer_size, MemType type = HOST);
+    void AddDMA(const uint32_t ptr, size_t pointer_size, MemType type = DMA);
+    void Remove(uintptr_t pointer, bool is_dma);
+    void RemoveHost(const void* ptr);
+    void RemoveDMA(const uint32_t ptr);
 
-  void DumpLiveToFile(int fd);
-  void DumpPeakInfo();
+    void DumpLiveToFile(int fd);
+    void DumpPeakInfo();
 
 private:
-  inline uintptr_t ManglePointer(uintptr_t pointer) { return pointer ^ UINTPTR_MAX; }
-  inline uintptr_t DemanglePointer(uintptr_t pointer) { return pointer ^ UINTPTR_MAX; }
+    inline uintptr_t ManglePointer(uintptr_t pointer) { return pointer ^ UINTPTR_MAX; }
+    inline uintptr_t DemanglePointer(uintptr_t pointer) {
+        return pointer ^ UINTPTR_MAX;
+    }
 
-  void GetList(std::vector<ListInfoType>* list, bool only_with_backtrace, Pred pred);
-  void GetUniqueList(std::vector<ListInfoType>* list, bool only_with_backtrace);
+    void GetList(std::vector<ListInfoType>* list, bool only_with_backtrace, Pred pred);
+    void GetUniqueList(std::vector<ListInfoType>* list, bool only_with_backtrace);
 
-  std::mutex pointer_mutex_;
-  std::unordered_map<uintptr_t, PointerInfoType> pointers_;
+    std::mutex pointer_mutex_;
+    std::unordered_map<uintptr_t, PointerInfoType> pointers_;
 
-  std::mutex frame_mutex_;
-  std::unordered_map<FrameKeyType, size_t> key_to_index_;
-  std::unordered_map<size_t, FrameInfoType> frames_;
-  std::unordered_map<size_t, std::shared_ptr<std::vector<unwindstack::FrameData>>> backtraces_info_;
-  size_t cur_hash_index_;
+    std::mutex frame_mutex_;
+    std::unordered_map<FrameKeyType, size_t> key_to_index_;
+    std::unordered_map<size_t, FrameInfoType> frames_;
+    std::unordered_map<size_t, std::shared_ptr<std::vector<unwindstack::FrameData>>>
+            backtraces_info_;
+    size_t cur_hash_index_;
 
-  size_t current_used, current_host, current_dma;
-  size_t peak_tot, peak_host, peak_dma;
-  std::vector<ListInfoType> peak_list;
+    size_t current_used, current_host, current_dma;
+    size_t peak_tot, peak_host, peak_dma;
+    std::vector<ListInfoType> peak_list;
 
-  BIONIC_DISALLOW_COPY_AND_ASSIGN(PointerData);
+    BIONIC_DISALLOW_COPY_AND_ASSIGN(PointerData);
 };

backtrace/include/UnwindBacktrace.h

@@ -33,4 +33,6 @@
 
 #include <unwindstack/Unwinder.h>
 
-unwindstack::ErrorCode Unwind(std::vector<uintptr_t>* frames, std::vector<unwindstack::FrameData>* info, size_t max_frames);
+unwindstack::ErrorCode Unwind(
+        std::vector<uintptr_t>* frames, std::vector<unwindstack::FrameData>* info,
+        size_t max_frames);

backtrace/include/debug_disable.h

@@ -15,20 +15,20 @@ bool DebugCallsDisabled();
 void DebugDisableSet(bool disable);
 
 class ScopedDisableDebugCalls {
- public:
-  ScopedDisableDebugCalls() : disabled_(DebugCallsDisabled()) {
-    if (!disabled_) {
-      DebugDisableSet(true);
+public:
+    ScopedDisableDebugCalls() : disabled_(DebugCallsDisabled()) {
+        if (!disabled_) {
+            DebugDisableSet(true);
+        }
     }
-  }
-  ~ScopedDisableDebugCalls() {
-    if (!disabled_) {
-      DebugDisableSet(false);
+    ~ScopedDisableDebugCalls() {
+        if (!disabled_) {
+            DebugDisableSet(false);
+        }
     }
-  }
 
- private:
-  bool disabled_;
+private:
+    bool disabled_;
 
-  BIONIC_DISALLOW_COPY_AND_ASSIGN(ScopedDisableDebugCalls);
+    BIONIC_DISALLOW_COPY_AND_ASSIGN(ScopedDisableDebugCalls);
 };

backtrace/include/memory_hook.h

@@ -10,5 +10,6 @@ extern void* (*m_sys_memalign)(size_t, size_t);
 extern int (*m_sys_posix_memalign)(void**, size_t, size_t);
 extern int (*m_sys_ioctl)(int fd, unsigned int request, ...);
 extern int (*m_sys_close)(int fd);
-extern void* (*m_sys_mmap)(void* addr, size_t size, int prot, int flags, int fd, off_t offset);
+extern void* (*m_sys_mmap)(
+        void* addr, size_t size, int prot, int flags, int fd, off_t offset);
 extern int (*m_sys_munmap)(void* addr, size_t size);

backtrace/src/Config.cpp

@@ -1,19 +1,19 @@
+#include <bionic/reserved_signals.h>
 #include <cassert>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
-#include <bionic/reserved_signals.h>
 
 #include "Config.h"
 
-
 static constexpr size_t DEFAULT_BACKTRACE_FRAMES = 128;
-static constexpr const char DEFAULT_BACKTRACE_DUMP_PREFIX[] = "/data/local/tmp/trace/backtrace_heap";
+static constexpr const char DEFAULT_BACKTRACE_DUMP_PREFIX[] =
+        "/data/local/tmp/trace/backtrace_heap";
 
 static bool ParseValue(const char* value, size_t* parsed_value) {
     *parsed_value = 0;
     if (value == nullptr) {
-        return  false;
+        return false;
     }
     *parsed_value = static_cast<size_t>(atol(value)) * 1024 * 1024;
     return true;
@@ -44,7 +44,7 @@ bool Config::Init() {
 
     // 通过信号插入 check point
     options_ |= DUMP_ON_SINGAL;
-    backtrace_dump_signal_ = BIONIC_SIGNAL_BACKTRACE; // BIONIC_SIGNAL_BACKTRACE: 33
+    backtrace_dump_signal_ = BIONIC_SIGNAL_BACKTRACE;  // BIONIC_SIGNAL_BACKTRACE: 33
 
     return true;
 }

backtrace/src/DebugData.cpp

@@ -7,7 +7,7 @@ bool DebugData::Initialize(void* storage) {
 
     pointer.reset(new (storage) PointerData());
     if (!pointer->Initialize(config_)) {
-      return false;
+        return false;
     }
 
     return true;