76 
  77 #ifdef AMD64
  78 #define REG_SP REG_RSP
  79 #define REG_PC REG_RIP
  80 #define REG_FP REG_RBP
  81 #define SPELL_REG_SP "rsp"
  82 #define SPELL_REG_FP "rbp"
  83 #else
  84 #define REG_SP REG_UESP
  85 #define REG_PC REG_EIP
  86 #define REG_FP REG_EBP
  87 #define SPELL_REG_SP "esp"
  88 #define SPELL_REG_FP "ebp"
  89 #endif // AMD64
  90 
  91 address os::current_stack_pointer() {
  92 #ifdef SPARC_WORKS
  93   register void *esp;
  94   __asm__("mov %%"SPELL_REG_SP", %0":"=r"(esp));
  95   return (address) ((char*)esp + sizeof(long)*2);




  96 #else
  97   register void *esp __asm__ (SPELL_REG_SP);
  98   return (address) esp;
  99 #endif
 100 }
 101 
 102 char* os::non_memory_address_word() {
 103   // Must never look like an address returned by reserve_memory,
 104   // even in its subfields (as defined by the CPU immediate fields,
 105   // if the CPU splits constants across multiple instructions).
 106 
 107   return (char*) -1;
 108 }
 109 
 110 void os::initialize_thread(Thread* thr) {
 111 // Nothing to do.
 112 }
 113 
 114 address os::Linux::ucontext_get_pc(ucontext_t * uc) {
 115   return (address)uc->uc_mcontext.gregs[REG_PC];

 158   return epc;
 159 }
 160 
 161 frame os::fetch_frame_from_context(void* ucVoid) {
 162   intptr_t* sp;
 163   intptr_t* fp;
 164   ExtendedPC epc = fetch_frame_from_context(ucVoid, &sp, &fp);
 165   return frame(sp, fp, epc.pc());
 166 }
 167 
 168 // By default, gcc always save frame pointer (%ebp/%rbp) on stack. It may get
 169 // turned off by -fomit-frame-pointer,
 170 frame os::get_sender_for_C_frame(frame* fr) {
 171   return frame(fr->sender_sp(), fr->link(), fr->sender_pc());
 172 }
 173 
 174 intptr_t* _get_previous_fp() {
 175 #ifdef SPARC_WORKS
 176   register intptr_t **ebp;
 177   __asm__("mov %%"SPELL_REG_FP", %0":"=r"(ebp));



 178 #else
 179   register intptr_t **ebp __asm__ (SPELL_REG_FP);
 180 #endif
 181   return (intptr_t*) *ebp;   // we want what it points to.
 182 }
 183 
 184 
 185 frame os::current_frame() {
 186   intptr_t* fp = _get_previous_fp();
 187   frame myframe((intptr_t*)os::current_stack_pointer(),
 188                 (intptr_t*)fp,
 189                 CAST_FROM_FN_PTR(address, os::current_frame));
 190   if (os::is_first_C_frame(&myframe)) {
 191     // stack is not walkable
 192     return frame();
 193   } else {
 194     return os::get_sender_for_C_frame(&myframe);
 195   }
 196 }
 197 

  76 
  77 #ifdef AMD64
  78 #define REG_SP REG_RSP
  79 #define REG_PC REG_RIP
  80 #define REG_FP REG_RBP
  81 #define SPELL_REG_SP "rsp"
  82 #define SPELL_REG_FP "rbp"
  83 #else
  84 #define REG_SP REG_UESP
  85 #define REG_PC REG_EIP
  86 #define REG_FP REG_EBP
  87 #define SPELL_REG_SP "esp"
  88 #define SPELL_REG_FP "ebp"
  89 #endif // AMD64
  90 
  91 address os::current_stack_pointer() {
  92 #ifdef SPARC_WORKS
  93   register void *esp;
  94   __asm__("mov %%"SPELL_REG_SP", %0":"=r"(esp));
  95   return (address) ((char*)esp + sizeof(long)*2);
  96 #elif defined(__clang__)
  97   intptr_t* esp;
  98   __asm__ __volatile__ ("mov %%"SPELL_REG_SP", %0":"=r"(esp):);
  99   return (address) esp;
 100 #else
 101   register void *esp __asm__ (SPELL_REG_SP);
 102   return (address) esp;
 103 #endif
 104 }
 105 
 106 char* os::non_memory_address_word() {
 107   // Must never look like an address returned by reserve_memory,
 108   // even in its subfields (as defined by the CPU immediate fields,
 109   // if the CPU splits constants across multiple instructions).
 110 
 111   return (char*) -1;
 112 }
 113 
 114 void os::initialize_thread(Thread* thr) {
 115 // Nothing to do.
 116 }
 117 
 118 address os::Linux::ucontext_get_pc(ucontext_t * uc) {
 119   return (address)uc->uc_mcontext.gregs[REG_PC];

 162   return epc;
 163 }
 164 
 165 frame os::fetch_frame_from_context(void* ucVoid) {
 166   intptr_t* sp;
 167   intptr_t* fp;
 168   ExtendedPC epc = fetch_frame_from_context(ucVoid, &sp, &fp);
 169   return frame(sp, fp, epc.pc());
 170 }
 171 
 172 // By default, gcc always save frame pointer (%ebp/%rbp) on stack. It may get
 173 // turned off by -fomit-frame-pointer,
 174 frame os::get_sender_for_C_frame(frame* fr) {
 175   return frame(fr->sender_sp(), fr->link(), fr->sender_pc());
 176 }
 177 
 178 intptr_t* _get_previous_fp() {
 179 #ifdef SPARC_WORKS
 180   register intptr_t **ebp;
 181   __asm__("mov %%"SPELL_REG_FP", %0":"=r"(ebp));
 182 #elif defined(__clang__)
 183   intptr_t **ebp;
 184   __asm__ __volatile__ ("mov %%"SPELL_REG_FP", %0":"=r"(ebp):);
 185 #else
 186   register intptr_t **ebp __asm__ (SPELL_REG_FP);
 187 #endif
 188   return (intptr_t*) *ebp;   // we want what it points to.
 189 }
 190 
 191 
 192 frame os::current_frame() {
 193   intptr_t* fp = _get_previous_fp();
 194   frame myframe((intptr_t*)os::current_stack_pointer(),
 195                 (intptr_t*)fp,
 196                 CAST_FROM_FN_PTR(address, os::current_frame));
 197   if (os::is_first_C_frame(&myframe)) {
 198     // stack is not walkable
 199     return frame();
 200   } else {
 201     return os::get_sender_for_C_frame(&myframe);
 202   }
 203 }
 204