16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "prims/jvm.h"
  27 #include "runtime/mutexLocker.hpp"
  28 #include "runtime/os.hpp"
  29 #include "utilities/decoder.hpp"
  30 #include "utilities/vmError.hpp"
  31 
  32 #if defined(_WINDOWS)
  33   #include "decoder_windows.hpp"
  34 #elif defined(__APPLE__)
  35   #include "decoder_machO.hpp"


  36 #else
  37   #include "decoder_elf.hpp"
  38 #endif
  39 
  40 AbstractDecoder*  Decoder::_shared_decoder = NULL;
  41 AbstractDecoder*  Decoder::_error_handler_decoder = NULL;
  42 NullDecoder       Decoder::_do_nothing_decoder;
  43 Mutex*            Decoder::_shared_decoder_lock = new Mutex(Mutex::native,
  44                                 "SharedDecoderLock");
  45 
  46 AbstractDecoder* Decoder::get_shared_instance() {
  47   assert(_shared_decoder_lock != NULL && _shared_decoder_lock->owned_by_self(),
  48     "Require DecoderLock to enter");
  49 
  50   if (_shared_decoder == NULL) {
  51     _shared_decoder = create_decoder();
  52   }
  53   return _shared_decoder;
  54 }
  55 
  56 AbstractDecoder* Decoder::get_error_handler_instance() {
  57   if (_error_handler_decoder == NULL) {
  58     _error_handler_decoder = create_decoder();
  59   }
  60   return _error_handler_decoder;
  61 }
  62 
  63 
  64 AbstractDecoder* Decoder::create_decoder() {
  65   AbstractDecoder* decoder;
  66 #if defined(_WINDOWS)
  67   decoder = new (std::nothrow) WindowsDecoder();
  68 #elif defined (__APPLE__)
  69   decoder = new (std::nothrow)MachODecoder();


  70 #else
  71   decoder = new (std::nothrow)ElfDecoder();
  72 #endif
  73 
  74   if (decoder == NULL || decoder->has_error()) {
  75     if (decoder != NULL) {
  76       delete decoder;
  77     }
  78     decoder = &_do_nothing_decoder;
  79   }
  80   return decoder;
  81 }
  82 
  83 bool Decoder::decode(address addr, char* buf, int buflen, int* offset, const char* modulepath) {
  84   assert(_shared_decoder_lock != NULL, "Just check");
  85   bool error_handling_thread = os::current_thread_id() == VMError::first_error_tid;
  86   MutexLockerEx locker(error_handling_thread ? NULL : _shared_decoder_lock, true);
  87   AbstractDecoder* decoder = error_handling_thread ?
  88     get_error_handler_instance(): get_shared_instance();
  89   assert(decoder != NULL, "null decoder");

  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "prims/jvm.h"
  27 #include "runtime/mutexLocker.hpp"
  28 #include "runtime/os.hpp"
  29 #include "utilities/decoder.hpp"
  30 #include "utilities/vmError.hpp"
  31 
  32 #if defined(_WINDOWS)
  33   #include "decoder_windows.hpp"
  34 #elif defined(__APPLE__)
  35   #include "decoder_machO.hpp"
  36 #elif defined(AIX)
  37   #include "decoder_aix.hpp"
  38 #else
  39   #include "decoder_elf.hpp"
  40 #endif
  41 
  42 AbstractDecoder*  Decoder::_shared_decoder = NULL;
  43 AbstractDecoder*  Decoder::_error_handler_decoder = NULL;
  44 NullDecoder       Decoder::_do_nothing_decoder;
  45 Mutex*            Decoder::_shared_decoder_lock = new Mutex(Mutex::native,
  46                                 "SharedDecoderLock");
  47 
  48 AbstractDecoder* Decoder::get_shared_instance() {
  49   assert(_shared_decoder_lock != NULL && _shared_decoder_lock->owned_by_self(),
  50     "Require DecoderLock to enter");
  51 
  52   if (_shared_decoder == NULL) {
  53     _shared_decoder = create_decoder();
  54   }
  55   return _shared_decoder;
  56 }
  57 
  58 AbstractDecoder* Decoder::get_error_handler_instance() {
  59   if (_error_handler_decoder == NULL) {
  60     _error_handler_decoder = create_decoder();
  61   }
  62   return _error_handler_decoder;
  63 }
  64 
  65 
  66 AbstractDecoder* Decoder::create_decoder() {
  67   AbstractDecoder* decoder;
  68 #if defined(_WINDOWS)
  69   decoder = new (std::nothrow) WindowsDecoder();
  70 #elif defined (__APPLE__)
  71   decoder = new (std::nothrow)MachODecoder();
  72 #elif defined(AIX)
  73   decoder = new (std::nothrow)AIXDecoder();
  74 #else
  75   decoder = new (std::nothrow)ElfDecoder();
  76 #endif
  77 
  78   if (decoder == NULL || decoder->has_error()) {
  79     if (decoder != NULL) {
  80       delete decoder;
  81     }
  82     decoder = &_do_nothing_decoder;
  83   }
  84   return decoder;
  85 }
  86 
  87 bool Decoder::decode(address addr, char* buf, int buflen, int* offset, const char* modulepath) {
  88   assert(_shared_decoder_lock != NULL, "Just check");
  89   bool error_handling_thread = os::current_thread_id() == VMError::first_error_tid;
  90   MutexLockerEx locker(error_handling_thread ? NULL : _shared_decoder_lock, true);
  91   AbstractDecoder* decoder = error_handling_thread ?
  92     get_error_handler_instance(): get_shared_instance();
  93   assert(decoder != NULL, "null decoder");