js/jsd/jsd_hook.cpp

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 /*
   7  * JavaScript Debugging support - Hook support
   8  */
   9
  10 #include "jsd.h"
  11
  12 JSTrapStatus
  13 jsd_InterruptHandler(JSContext *cx, JSScript *script, jsbytecode *pc, jsval *rval,
  14                      void *closure)
  15 {
  16     JSDScript*      jsdscript;
  17     JSDContext*     jsdc = (JSDContext*) closure;
  18     JSD_ExecutionHookProc hook;
  19     void*                 hookData;
  20
  21     if( ! jsdc || ! jsdc->inited )
  22         return JSTRAP_CONTINUE;
  23
  24     if( JSD_IS_DANGEROUS_THREAD(jsdc) )
  25         return JSTRAP_CONTINUE;
  26
  27     /* local in case jsdc->interruptHook gets cleared on another thread */
  28     JSD_LOCK();
  29     hook     = jsdc->interruptHook;
  30     hookData = jsdc->interruptHookData;
  31     JSD_UNLOCK();
  32
  33     if (!hook)
  34         return JSTRAP_CONTINUE;
  35
  36     JSD_LOCK_SCRIPTS(jsdc);
  37     jsdscript = jsd_FindOrCreateJSDScript(jsdc, cx, script, NULL);
  38     JSD_UNLOCK_SCRIPTS(jsdc);
  39     if( ! jsdscript )
  40         return JSTRAP_CONTINUE;
  41
  42 #ifdef LIVEWIRE
  43     if( ! jsdlw_UserCodeAtPC(jsdc, jsdscript, (uintptr_t)pc) )
  44         return JSTRAP_CONTINUE;
  45 #endif
  46
  47     return jsd_CallExecutionHook(jsdc, cx, JSD_HOOK_INTERRUPTED,
  48                                  hook, hookData, rval);
  49 }
  50
  51 JSTrapStatus
  52 jsd_DebuggerHandler(JSContext *cx, JSScript *script, jsbytecode *pc,
  53                     jsval *rval, void *closure)
  54 {
  55     JSDScript*      jsdscript;
  56     JSDContext*     jsdc = (JSDContext*) closure;
  57     JSD_ExecutionHookProc hook;
  58     void*                 hookData;
  59
  60     if( ! jsdc || ! jsdc->inited )
  61         return JSTRAP_CONTINUE;
  62
  63     if( JSD_IS_DANGEROUS_THREAD(jsdc) )
  64         return JSTRAP_CONTINUE;
  65
  66     /* local in case jsdc->debuggerHook gets cleared on another thread */
  67     JSD_LOCK();
  68     hook     = jsdc->debuggerHook;
  69     hookData = jsdc->debuggerHookData;
  70     JSD_UNLOCK();
  71     if(!hook)
  72         return JSTRAP_CONTINUE;
  73
  74     JSD_LOCK_SCRIPTS(jsdc);
  75     jsdscript = jsd_FindOrCreateJSDScript(jsdc, cx, script, NULL);
  76     JSD_UNLOCK_SCRIPTS(jsdc);
  77     if( ! jsdscript )
  78         return JSTRAP_CONTINUE;
  79
  80     return jsd_CallExecutionHook(jsdc, cx, JSD_HOOK_DEBUGGER_KEYWORD,
  81                                  hook, hookData, rval);
  82 }
  83
  84
  85 JSTrapStatus
  86 jsd_ThrowHandler(JSContext *cx, JSScript *script, jsbytecode *pc,
  87                  jsval *rval, void *closure)
  88 {
  89     JSDScript*      jsdscript;
  90     JSDContext*     jsdc = (JSDContext*) closure;
  91     JSD_ExecutionHookProc hook;
  92     void*                 hookData;
  93
  94     if( ! jsdc || ! jsdc->inited )
  95         return JSTRAP_CONTINUE;
  96
  97     if( JSD_IS_DANGEROUS_THREAD(jsdc) )
  98         return JSTRAP_CONTINUE;
  99
 100     /* local in case jsdc->throwHook gets cleared on another thread */
 101     JSD_LOCK();
 102     hook     = jsdc->throwHook;
 103     hookData = jsdc->throwHookData;
 104     JSD_UNLOCK();
 105     if (!hook)
 106         return JSTRAP_CONTINUE;
 107
 108     JSD_LOCK_SCRIPTS(jsdc);
 109     jsdscript = jsd_FindOrCreateJSDScript(jsdc, cx, script, NULL);
 110     JSD_UNLOCK_SCRIPTS(jsdc);
 111     if( ! jsdscript )
 112         return JSTRAP_CONTINUE;
 113
 114     JS_GetPendingException(cx, rval);
 115
 116     return jsd_CallExecutionHook(jsdc, cx, JSD_HOOK_THROW,
 117                                  hook, hookData, rval);
 118 }
 119
 120 JSTrapStatus
 121 jsd_CallExecutionHook(JSDContext* jsdc,
 122                       JSContext *cx,
 123                       unsigned type,
 124                       JSD_ExecutionHookProc hook,
 125                       void* hookData,
 126                       jsval* rval)
 127 {
 128     unsigned hookanswer = JSD_HOOK_THROW == type ?
 129                             JSD_HOOK_RETURN_CONTINUE_THROW :
 130                             JSD_HOOK_RETURN_CONTINUE;
 131     JSDThreadState* jsdthreadstate;
 132
 133     if(hook && NULL != (jsdthreadstate = jsd_NewThreadState(jsdc,cx)))
 134     {
 135         if ((type != JSD_HOOK_THROW && type != JSD_HOOK_INTERRUPTED) ||
 136             jsdc->flags & JSD_MASK_TOP_FRAME_ONLY ||
 137             !(jsdthreadstate->flags & TS_HAS_DISABLED_FRAME))
 138         {
 139             /*
 140              * if it's not a throw and it's not an interrupt,
 141              * or we're only masking the top frame,
 142              * or there are no disabled frames in this stack,
 143              * then call out.
 144              */
 145              hookanswer = hook(jsdc, jsdthreadstate, type, hookData, rval);
 146              jsd_DestroyThreadState(jsdc, jsdthreadstate);
 147         }
 148     }
 149
 150     switch(hookanswer)
 151     {
 152         case JSD_HOOK_RETURN_ABORT:
 153         case JSD_HOOK_RETURN_HOOK_ERROR:
 154             return JSTRAP_ERROR;
 155         case JSD_HOOK_RETURN_RET_WITH_VAL:
 156             return JSTRAP_RETURN;
 157         case JSD_HOOK_RETURN_THROW_WITH_VAL:
 158             return JSTRAP_THROW;
 159         case JSD_HOOK_RETURN_CONTINUE:
 160             break;
 161         case JSD_HOOK_RETURN_CONTINUE_THROW:
 162             /* only makes sense for jsd_ThrowHandler (which init'd rval) */
 163             JS_ASSERT(JSD_HOOK_THROW == type);
 164             return JSTRAP_THROW;
 165         default:
 166             JS_ASSERT(0);
 167             break;
 168     }
 169     return JSTRAP_CONTINUE;
 170 }
 171
 172 JSBool
 173 jsd_CallCallHook (JSDContext* jsdc,
 174                   JSContext *cx,
 175                   unsigned type,
 176                   JSD_CallHookProc hook,
 177                   void* hookData)
 178 {
 179     JSBool hookanswer;
 180     JSDThreadState*  jsdthreadstate;
 181
 182     hookanswer = JS_FALSE;
 183     if(hook && NULL != (jsdthreadstate = jsd_NewThreadState(jsdc, cx)))
 184     {
 185         hookanswer = hook(jsdc, jsdthreadstate, type, hookData);
 186         jsd_DestroyThreadState(jsdc, jsdthreadstate);
 187     }
 188
 189     return hookanswer;
 190 }
 191
 192 JSBool
 193 jsd_SetInterruptHook(JSDContext*           jsdc,
 194                      JSD_ExecutionHookProc hook,
 195                      void*                 callerdata)
 196 {
 197     JSD_LOCK();
 198     jsdc->interruptHookData  = callerdata;
 199     jsdc->interruptHook      = hook;
 200     JS_SetInterrupt(jsdc->jsrt, jsd_InterruptHandler, (void*) jsdc);
 201     JSD_UNLOCK();
 202
 203     return JS_TRUE;
 204 }
 205
 206 JSBool
 207 jsd_ClearInterruptHook(JSDContext* jsdc)
 208 {
 209     JSD_LOCK();
 210     JS_ClearInterrupt(jsdc->jsrt, NULL, NULL );
 211     jsdc->interruptHook      = NULL;
 212     JSD_UNLOCK();
 213
 214     return JS_TRUE;
 215 }
 216
 217 JSBool
 218 jsd_SetDebugBreakHook(JSDContext*           jsdc,
 219                       JSD_ExecutionHookProc hook,
 220                       void*                 callerdata)
 221 {
 222     JSD_LOCK();
 223     jsdc->debugBreakHookData  = callerdata;
 224     jsdc->debugBreakHook      = hook;
 225     JSD_UNLOCK();
 226
 227     return JS_TRUE;
 228 }
 229
 230 JSBool
 231 jsd_ClearDebugBreakHook(JSDContext* jsdc)
 232 {
 233     JSD_LOCK();
 234     jsdc->debugBreakHook      = NULL;
 235     JSD_UNLOCK();
 236
 237     return JS_TRUE;
 238 }
 239
 240 JSBool
 241 jsd_SetDebuggerHook(JSDContext*           jsdc,
 242                       JSD_ExecutionHookProc hook,
 243                       void*                 callerdata)
 244 {
 245     JSD_LOCK();
 246     jsdc->debuggerHookData  = callerdata;
 247     jsdc->debuggerHook      = hook;
 248     JSD_UNLOCK();
 249
 250     return JS_TRUE;
 251 }
 252
 253 JSBool
 254 jsd_ClearDebuggerHook(JSDContext* jsdc)
 255 {
 256     JSD_LOCK();
 257     jsdc->debuggerHook      = NULL;
 258     JSD_UNLOCK();
 259
 260     return JS_TRUE;
 261 }
 262
 263 JSBool
 264 jsd_SetThrowHook(JSDContext*           jsdc,
 265                  JSD_ExecutionHookProc hook,
 266                  void*                 callerdata)
 267 {
 268     JSD_LOCK();
 269     jsdc->throwHookData  = callerdata;
 270     jsdc->throwHook      = hook;
 271     JSD_UNLOCK();
 272
 273     return JS_TRUE;
 274 }
 275
 276 JSBool
 277 jsd_ClearThrowHook(JSDContext* jsdc)
 278 {
 279     JSD_LOCK();
 280     jsdc->throwHook      = NULL;
 281     JSD_UNLOCK();
 282
 283     return JS_TRUE;
 284 }
 285
 286 JSBool
 287 jsd_SetFunctionHook(JSDContext*      jsdc,
 288                     JSD_CallHookProc hook,
 289                     void*            callerdata)
 290 {
 291     JSD_LOCK();
 292     jsdc->functionHookData  = callerdata;
 293     jsdc->functionHook      = hook;
 294     JSD_UNLOCK();
 295
 296     return JS_TRUE;
 297 }
 298
 299 JSBool
 300 jsd_ClearFunctionHook(JSDContext* jsdc)
 301 {
 302     JSD_LOCK();
 303     jsdc->functionHook      = NULL;
 304     JSD_UNLOCK();
 305
 306     return JS_TRUE;
 307 }
 308
 309 JSBool
 310 jsd_SetTopLevelHook(JSDContext*      jsdc,
 311                     JSD_CallHookProc hook,
 312                     void*            callerdata)
 313 {
 314     JSD_LOCK();
 315     jsdc->toplevelHookData  = callerdata;
 316     jsdc->toplevelHook      = hook;
 317     JSD_UNLOCK();
 318
 319     return JS_TRUE;
 320 }
 321
 322 JSBool
 323 jsd_ClearTopLevelHook(JSDContext* jsdc)
 324 {
 325     JSD_LOCK();
 326     jsdc->toplevelHook      = NULL;
 327     JSD_UNLOCK();
 328
 329     return JS_TRUE;
 330 }
 331