Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===-- OProfileWrapper.h - OProfile JIT API Wrapper ------------*- C++ -*-===//
  2. //
  3. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4. // See https://llvm.org/LICENSE.txt for license information.
  5. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6. //
  7. //===----------------------------------------------------------------------===//
  8. // This file defines a OProfileWrapper object that detects if the oprofile
  9. // daemon is running, and provides wrappers for opagent functions used to
  10. // communicate with the oprofile JIT interface. The dynamic library libopagent
  11. // does not need to be linked directly as this object lazily loads the library
  12. // when the first op_ function is called.
  13. //
  14. // See http://oprofile.sourceforge.net/doc/devel/jit-interface.html for the
  15. // definition of the interface.
  16. //
  17. //===----------------------------------------------------------------------===//
  18.  
  19. #ifndef LLVM_EXECUTIONENGINE_OPROFILEWRAPPER_H
  20. #define LLVM_EXECUTIONENGINE_OPROFILEWRAPPER_H
  21.  
  22. #include "llvm/Support/DataTypes.h"
  23. #include <opagent.h>
  24.  
  25. namespace llvm {
  26.  
  27.  
  28. class OProfileWrapper {
  29.   typedef  op_agent_t    (*op_open_agent_ptr_t)();
  30.   typedef  int           (*op_close_agent_ptr_t)(op_agent_t);
  31.   typedef  int           (*op_write_native_code_ptr_t)(op_agent_t,
  32.                                                 const char*,
  33.                                                 uint64_t,
  34.                                                 void const*,
  35.                                                 const unsigned int);
  36.   typedef  int           (*op_write_debug_line_info_ptr_t)(op_agent_t,
  37.                                                 void const*,
  38.                                                 size_t,
  39.                                                 struct debug_line_info const*);
  40.   typedef  int           (*op_unload_native_code_ptr_t)(op_agent_t, uint64_t);
  41.  
  42.   // Also used for op_minor_version function which has the same signature
  43.   typedef  int           (*op_major_version_ptr_t)();
  44.  
  45.   // This is not a part of the opagent API, but is useful nonetheless
  46.   typedef  bool          (*IsOProfileRunningPtrT)();
  47.  
  48.  
  49.   op_agent_t                      Agent;
  50.   op_open_agent_ptr_t             OpenAgentFunc;
  51.   op_close_agent_ptr_t            CloseAgentFunc;
  52.   op_write_native_code_ptr_t      WriteNativeCodeFunc;
  53.   op_write_debug_line_info_ptr_t  WriteDebugLineInfoFunc;
  54.   op_unload_native_code_ptr_t     UnloadNativeCodeFunc;
  55.   op_major_version_ptr_t          MajorVersionFunc;
  56.   op_major_version_ptr_t          MinorVersionFunc;
  57.   IsOProfileRunningPtrT           IsOProfileRunningFunc;
  58.  
  59.   bool Initialized;
  60.  
  61. public:
  62.   OProfileWrapper();
  63.  
  64.   // For testing with a mock opagent implementation, skips the dynamic load and
  65.   // the function resolution.
  66.   OProfileWrapper(op_open_agent_ptr_t OpenAgentImpl,
  67.                   op_close_agent_ptr_t CloseAgentImpl,
  68.                   op_write_native_code_ptr_t WriteNativeCodeImpl,
  69.                   op_write_debug_line_info_ptr_t WriteDebugLineInfoImpl,
  70.                   op_unload_native_code_ptr_t UnloadNativeCodeImpl,
  71.                   op_major_version_ptr_t MajorVersionImpl,
  72.                   op_major_version_ptr_t MinorVersionImpl,
  73.                   IsOProfileRunningPtrT MockIsOProfileRunningImpl = 0)
  74.   : OpenAgentFunc(OpenAgentImpl),
  75.     CloseAgentFunc(CloseAgentImpl),
  76.     WriteNativeCodeFunc(WriteNativeCodeImpl),
  77.     WriteDebugLineInfoFunc(WriteDebugLineInfoImpl),
  78.     UnloadNativeCodeFunc(UnloadNativeCodeImpl),
  79.     MajorVersionFunc(MajorVersionImpl),
  80.     MinorVersionFunc(MinorVersionImpl),
  81.     IsOProfileRunningFunc(MockIsOProfileRunningImpl),
  82.     Initialized(true)
  83.   {
  84.   }
  85.  
  86.   // Calls op_open_agent in the oprofile JIT library and saves the returned
  87.   // op_agent_t handle internally so it can be used when calling all the other
  88.   // op_* functions. Callers of this class do not need to keep track of
  89.   // op_agent_t objects.
  90.   bool op_open_agent();
  91.  
  92.   int op_close_agent();
  93.   int op_write_native_code(const char* name,
  94.                            uint64_t addr,
  95.                            void const* code,
  96.                            const unsigned int size);
  97.   int op_write_debug_line_info(void const* code,
  98.                                size_t num_entries,
  99.                                struct debug_line_info const* info);
  100.   int op_unload_native_code(uint64_t addr);
  101.   int op_major_version();
  102.   int op_minor_version();
  103.  
  104.   // Returns true if the oprofiled process is running, the opagent library is
  105.   // loaded and a connection to the agent has been established, and false
  106.   // otherwise.
  107.   bool isAgentAvailable();
  108.  
  109. private:
  110.   // Loads the libopagent library and initializes this wrapper if the oprofile
  111.   // daemon is running
  112.   bool initialize();
  113.  
  114.   // Searches /proc for the oprofile daemon and returns true if the process if
  115.   // found, or false otherwise.
  116.   bool checkForOProfileProcEntry();
  117.  
  118.   bool isOProfileRunning();
  119. };
  120.  
  121. } // namespace llvm
  122.  
  123. #endif // LLVM_EXECUTIONENGINE_OPROFILEWRAPPER_H
  124.