1 files changed, 106 insertions, 107 deletions

diff --git a/source/ucli/symbol.h b/source/ucli/symbol.h
index 4f074fa..dce35e7 100644
--- a/source/ucli/symbol.h
+++ b/source/ucli/symbol.h
@@ -7,141 +7,140 @@
 
 #define INVALID_ADDR ((size_t)(-1))
 enum {
-    NATIVE_TYPE = 0,
-    JIT_TYPE = 1,
-    UNKNOWN = 2,
+  NATIVE_TYPE = 0,
+  JIT_TYPE = 1,
+  UNKNOWN = 2,
 };
 
 struct elf_file {
-    unsigned char elf_read_error;
-    size_t		  eh_frame_hdr_offset;
-    size_t		  fde_count;
-    size_t		  table_data;
-    std::string filename;
-    int type;
-
-    elf_file(const std::string &name) : filename(name), type(NATIVE_TYPE) {
-        elf_read_error = 0;
-        eh_frame_hdr_offset = 0;
-        fde_count = 0;
-        table_data = 0;
-    }
-
-    elf_file() :type(NATIVE_TYPE) {}
-
-    void reset(const std::string &name) {
-        filename = name;
-        elf_read_error = 0;
-        eh_frame_hdr_offset = 0;
-        fde_count = 0;
-        table_data = 0;
-    }
-
-    bool operator<  (const elf_file &rhs) const {
-        return filename < rhs.filename;
-    }
+  unsigned char elf_read_error;
+  size_t eh_frame_hdr_offset;
+  size_t fde_count;
+  size_t table_data;
+  std::string filename;
+  int type;
+
+  elf_file(const std::string &name) : filename(name), type(NATIVE_TYPE) {
+    elf_read_error = 0;
+    eh_frame_hdr_offset = 0;
+    fde_count = 0;
+    table_data = 0;
+  }
+
+  elf_file() : type(NATIVE_TYPE) {}
+
+  void reset(const std::string &name) {
+    filename = name;
+    elf_read_error = 0;
+    eh_frame_hdr_offset = 0;
+    fde_count = 0;
+    table_data = 0;
+  }
+
+  bool operator<(const elf_file &rhs) const { return filename < rhs.filename; }
 };
 
 struct vma {
-    size_t start;
-    size_t end;
-    size_t offset;
-    size_t pc;
-    int type;
-    std::string name;
-    struct {
-        unsigned char elf_read_error;
-        size_t		  eh_frame_hdr_offset;
-        size_t		  fde_count;
-        size_t		  table_data;
-    };
-
-    size_t map(size_t pc) {
-        // printf("pc: %lx, start: %lx, offset: %lx\n", pc, start, offset);
-        return pc - start + offset;
-    }
+  size_t start;
+  size_t end;
+  size_t offset;
+  size_t pc;
+  int type;
+  std::string name;
+  struct {
+    unsigned char elf_read_error;
+    size_t eh_frame_hdr_offset;
+    size_t fde_count;
+    size_t table_data;
+  };
 
-    void set_type(int t) { type = t; }
+  size_t map(size_t pc) {
+    // printf("pc: %lx, start: %lx, offset: %lx\n", pc, start, offset);
+    return pc - start + offset;
+  }
 
-    vma(size_t s, size_t e, size_t o, const std::string &n)
-        :start(s), end(e), offset(o), pc(0), type(NATIVE_TYPE), name(n)  {}
+  void set_type(int t) { type = t; }
 
-    vma() : start(0), end(0), offset(0), pc(0), type(NATIVE_TYPE) {}
+  vma(size_t s, size_t e, size_t o, const std::string &n)
+      : start(s), end(e), offset(o), pc(0), type(NATIVE_TYPE), name(n) {}
 
-    vma(size_t addr) : start(0), end(0), offset(0), pc(addr), type(NATIVE_TYPE) {}
+  vma() : start(0), end(0), offset(0), pc(0), type(NATIVE_TYPE) {}
 
-    bool operator<(const vma &vm) {
-       return vm.start < vm.pc;
-    }
+  vma(size_t addr) : start(0), end(0), offset(0), pc(addr), type(NATIVE_TYPE) {}
+
+  bool operator<(const vma &vm) { return vm.start < vm.pc; }
 
-    vma &operator=(const vma &vm) {
-        if (this == &vm) {
-            return *this;
-        }
-        start = vm.start;
-        end = vm.end;
-        offset = vm.offset;
-        name = vm.name;
-        return *this;
+  vma &operator=(const vma &vm) {
+    if (this == &vm) {
+      return *this;
     }
+    start = vm.start;
+    end = vm.end;
+    offset = vm.offset;
+    name = vm.name;
+    return *this;
+  }
 };
 
 struct symbol {
-    size_t start;
-    size_t end;
-    size_t ip;
-    size_t base;
-    std::string name;
-
-    symbol() :start(0), end(0), ip(0) , base(0) {}
-    symbol(size_t pc) :start(0), end(0), ip(pc) {}
-
-    void reset(size_t va) { start = end = 0; ip = va; }
-    bool operator< (const symbol &sym) const {
-        return sym.ip < start;
-    }
-
-    bool operator> (const symbol &sym) const {
-        return sym.ip > end;
-    }
+  size_t start;
+  size_t end;
+  size_t ip;
+  size_t base;
+  std::string name;
+
+  symbol() : start(0), end(0), ip(0), base(0) {}
+  symbol(size_t pc) : start(0), end(0), ip(pc) {}
+
+  void reset(size_t va) {
+    start = end = 0;
+    ip = va;
+  }
+  bool operator<(const symbol &sym) const { return sym.ip < start; }
+
+  bool operator>(const symbol &sym) const { return sym.ip > end; }
 };
 
 class symbol_parser {
 private:
-    typedef std::map<size_t, vma> proc_vma;
-
-    std::map<elf_file, std::set<symbol> > file_symbols;
-    std::map<int, std::set<symbol> > java_symbols;
-    std::set<symbol> kernel_symbols;
-    std::map<int, proc_vma> machine_vma;
-    std::set<int> java_procs;
-    std::map<int, std::map<unsigned long, std::string> > symbols_cache;
+  typedef std::map<size_t, vma> proc_vma;
+
+  std::map<elf_file, std::set<symbol>> file_symbols;
+  std::map<int, std::set<symbol>> java_symbols;
+  std::set<symbol> kernel_symbols;
+  std::map<int, proc_vma> machine_vma;
+  std::set<int> java_procs;
+  std::map<int, std::map<unsigned long, std::string>> symbols_cache;
+
 public:
-    bool load_kernel();
-    std::set<int>& get_java_procs() { return java_procs; }
+  bool load_kernel();
+  std::set<int> &get_java_procs() { return java_procs; }
 
-    bool find_kernel_symbol(symbol &sym);
-    bool find_elf_symbol(symbol &sym, const elf_file &file, int pid, int pid_ns);
-    bool find_java_symbol(symbol &sym, int pid, int pid_ns);
+  bool find_kernel_symbol(symbol &sym);
+  bool find_elf_symbol(symbol &sym, const elf_file &file, int pid, int pid_ns);
+  bool find_java_symbol(symbol &sym, int pid, int pid_ns);
 
-    bool get_symbol_info(int pid, symbol &sym, elf_file &file);
+  bool get_symbol_info(int pid, symbol &sym, elf_file &file);
 
-    bool find_vma(pid_t pid, vma &vm);
-    vma* find_vma(pid_t pid, size_t pc);
-    void clear_symbol_info(int);
-    bool add_pid_maps(int pid, size_t start, size_t end, size_t offset, const char *name);
+  bool find_vma(pid_t pid, vma &vm);
+  vma *find_vma(pid_t pid, size_t pc);
+  void clear_symbol_info(int);
+  bool add_pid_maps(int pid, size_t start, size_t end, size_t offset,
+                    const char *name);
 
-    bool find_symbol_in_cache(int tgid, unsigned long addr, std::string &symbol);
-    bool putin_symbol_cache(int tgid, unsigned long addr, std::string &symbol);
+  bool find_symbol_in_cache(int tgid, unsigned long addr, std::string &symbol);
+  bool putin_symbol_cache(int tgid, unsigned long addr, std::string &symbol);
+
+  void dump(void);
 
-    void dump(void);
 private:
-    bool load_pid_maps(int pid);
-    bool load_elf(pid_t pid, const elf_file& file, size_t file_base_addr);
-    bool load_perf_map(int pid, int pid_ns);
+  bool load_pid_maps(int pid);
+  bool load_elf(pid_t pid, const elf_file &file, size_t file_base_addr);
+  bool load_perf_map(int pid, int pid_ns);
+
 public:
-    int java_only;
-    int user_symbol;
+  int java_only;
+  int user_symbol;
 };
 
 extern symbol_parser g_symbol_parser;