js/jsd/jsd_high.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 - 'High Level' functions
   8  */
   9
  10 #include "jsd.h"
  11
  12 /***************************************************************************/
  13
  14 /* XXX not 'static' because of old Mac CodeWarrior bug */
  15 JSCList _jsd_context_list = JS_INIT_STATIC_CLIST(&_jsd_context_list);
  16
  17 /* these are used to connect JSD_SetUserCallbacks() with JSD_DebuggerOn() */
  18 static JSD_UserCallbacks _callbacks;
  19 static void*             _user = NULL;
  20 static JSRuntime*        _jsrt = NULL;
  21
  22 #ifdef JSD_HAS_DANGEROUS_THREAD
  23 static void* _dangerousThread = NULL;
  24 #endif
  25
  26 #ifdef JSD_THREADSAFE
  27 JSDStaticLock* _jsd_global_lock = NULL;
  28 #endif
  29
  30 #ifdef DEBUG
  31 void JSD_ASSERT_VALID_CONTEXT(JSDContext* jsdc)
  32 {
  33     JS_ASSERT(jsdc->inited);
  34     JS_ASSERT(jsdc->jsrt);
  35     JS_ASSERT(jsdc->dumbContext);
  36     JS_ASSERT(jsdc->glob);
  37 }
  38 #endif
  39
  40 static JSClass global_class = {
  41     "JSDGlobal", JSCLASS_GLOBAL_FLAGS,
  42     JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,  JS_StrictPropertyStub,
  43     JS_EnumerateStub, JS_ResolveStub,   JS_ConvertStub
  44 };
  45
  46 static JSBool
  47 _validateUserCallbacks(JSD_UserCallbacks* callbacks)
  48 {
  49     return !callbacks ||
  50            (callbacks->size && callbacks->size <= sizeof(JSD_UserCallbacks));
  51 }
  52
  53 static JSDContext*
  54 _newJSDContext(JSRuntime*         jsrt,
  55                JSD_UserCallbacks* callbacks,
  56                void*              user,
  57                JSObject*          scopeobj)
  58 {
  59     JSDContext* jsdc = NULL;
  60     JSCompartment *oldCompartment = NULL;
  61     JSBool ok;
  62
  63     if( ! jsrt )
  64         return NULL;
  65
  66     if( ! _validateUserCallbacks(callbacks) )
  67         return NULL;
  68
  69     jsdc = (JSDContext*) calloc(1, sizeof(JSDContext));
  70     if( ! jsdc )
  71         goto label_newJSDContext_failure;
  72
  73     if( ! JSD_INIT_LOCKS(jsdc) )
  74         goto label_newJSDContext_failure;
  75
  76     JS_INIT_CLIST(&jsdc->links);
  77
  78     jsdc->jsrt = jsrt;
  79
  80     if( callbacks )
  81         memcpy(&jsdc->userCallbacks, callbacks, callbacks->size);
  82
  83     jsdc->user = user;
  84
  85 #ifdef JSD_HAS_DANGEROUS_THREAD
  86     jsdc->dangerousThread = _dangerousThread;
  87 #endif
  88
  89     JS_INIT_CLIST(&jsdc->threadsStates);
  90     JS_INIT_CLIST(&jsdc->sources);
  91     JS_INIT_CLIST(&jsdc->removedSources);
  92
  93     jsdc->sourceAlterCount = 1;
  94
  95     if( ! jsd_CreateAtomTable(jsdc) )
  96         goto label_newJSDContext_failure;
  97
  98     if( ! jsd_InitObjectManager(jsdc) )
  99         goto label_newJSDContext_failure;
 100
 101     if( ! jsd_InitScriptManager(jsdc) )
 102         goto label_newJSDContext_failure;
 103
 104     jsdc->dumbContext = JS_NewContext(jsdc->jsrt, 256);
 105     if( ! jsdc->dumbContext )
 106         goto label_newJSDContext_failure;
 107
 108     JS_BeginRequest(jsdc->dumbContext);
 109     JS_SetOptions(jsdc->dumbContext, JS_GetOptions(jsdc->dumbContext));
 110
 111     jsdc->glob = JS_NewGlobalObject(jsdc->dumbContext, &global_class, NULL);
 112
 113     if( ! jsdc->glob )
 114         goto label_newJSDContext_failure;
 115
 116     oldCompartment = JS_EnterCompartment(jsdc->dumbContext, jsdc->glob);
 117
 118     if ( ! JS_AddNamedObjectRoot(jsdc->dumbContext, &jsdc->glob, "JSD context global") )
 119         goto label_newJSDContext_failure;
 120
 121     ok = JS_InitStandardClasses(jsdc->dumbContext, jsdc->glob);
 122
 123     JS_LeaveCompartment(jsdc->dumbContext, oldCompartment);
 124     if( ! ok )
 125         goto label_newJSDContext_failure;
 126
 127     JS_EndRequest(jsdc->dumbContext);
 128
 129     jsdc->data = NULL;
 130     jsdc->inited = JS_TRUE;
 131
 132     JSD_LOCK();
 133     JS_INSERT_LINK(&jsdc->links, &_jsd_context_list);
 134     JSD_UNLOCK();
 135
 136     return jsdc;
 137
 138 label_newJSDContext_failure:
 139     if( jsdc ) {
 140         if ( jsdc->dumbContext && jsdc->glob )
 141             JS_RemoveObjectRootRT(JS_GetRuntime(jsdc->dumbContext), &jsdc->glob);
 142         jsd_DestroyObjectManager(jsdc);
 143         jsd_DestroyAtomTable(jsdc);
 144         if( jsdc->dumbContext )
 145             JS_EndRequest(jsdc->dumbContext);
 146         free(jsdc);
 147     }
 148     return NULL;
 149 }
 150
 151 static void
 152 _destroyJSDContext(JSDContext* jsdc)
 153 {
 154     JSD_ASSERT_VALID_CONTEXT(jsdc);
 155
 156     JSD_LOCK();
 157     JS_REMOVE_LINK(&jsdc->links);
 158     JSD_UNLOCK();
 159
 160     if ( jsdc->dumbContext && jsdc->glob ) {
 161         JS_RemoveObjectRootRT(JS_GetRuntime(jsdc->dumbContext), &jsdc->glob);
 162     }
 163     jsd_DestroyObjectManager(jsdc);
 164     jsd_DestroyAtomTable(jsdc);
 165
 166     jsdc->inited = JS_FALSE;
 167
 168     /*
 169     * We should free jsdc here, but we let it leak in case there are any
 170     * asynchronous hooks calling into the system using it as a handle
 171     *
 172     * XXX we also leak the locks
 173     */
 174     JS_DestroyContext(jsdc->dumbContext);
 175     jsdc->dumbContext = NULL;
 176 }
 177
 178 /***************************************************************************/
 179
 180 JSDContext*
 181 jsd_DebuggerOnForUser(JSRuntime*         jsrt,
 182                       JSD_UserCallbacks* callbacks,
 183                       void*              user,
 184                       JSObject*          scopeobj)
 185 {
 186     JSDContext* jsdc;
 187
 188     jsdc = _newJSDContext(jsrt, callbacks, user, scopeobj);
 189     if( ! jsdc )
 190         return NULL;
 191
 192     /*
 193      * Set hooks here.  The new/destroy script hooks are on even when
 194      * the debugger is paused.  The destroy hook so we'll clean up
 195      * internal data structures when scripts are destroyed, and the
 196      * newscript hook for backwards compatibility for now.  We'd like
 197      * to stop doing that.
 198      */
 199     JS_SetNewScriptHookProc(jsdc->jsrt, jsd_NewScriptHookProc, jsdc);
 200     JS_SetDestroyScriptHookProc(jsdc->jsrt, jsd_DestroyScriptHookProc, jsdc);
 201     jsd_DebuggerUnpause(jsdc);
 202 #ifdef LIVEWIRE
 203     LWDBG_SetNewScriptHookProc(jsd_NewScriptHookProc, jsdc);
 204 #endif
 205     if( jsdc->userCallbacks.setContext )
 206         jsdc->userCallbacks.setContext(jsdc, jsdc->user);
 207     return jsdc;
 208 }
 209
 210 JSDContext*
 211 jsd_DebuggerOn(void)
 212 {
 213     JS_ASSERT(_jsrt);
 214     JS_ASSERT(_validateUserCallbacks(&_callbacks));
 215     return jsd_DebuggerOnForUser(_jsrt, &_callbacks, _user, NULL);
 216 }
 217
 218 void
 219 jsd_DebuggerOff(JSDContext* jsdc)
 220 {
 221     jsd_DebuggerPause(jsdc, JS_TRUE);
 222     /* clear hooks here */
 223     JS_SetNewScriptHookProc(jsdc->jsrt, NULL, NULL);
 224     JS_SetDestroyScriptHookProc(jsdc->jsrt, NULL, NULL);
 225 #ifdef LIVEWIRE
 226     LWDBG_SetNewScriptHookProc(NULL,NULL);
 227 #endif
 228
 229     /* clean up */
 230     JSD_LockScriptSubsystem(jsdc);
 231     jsd_DestroyScriptManager(jsdc);
 232     JSD_UnlockScriptSubsystem(jsdc);
 233     jsd_DestroyAllSources(jsdc);
 234
 235     _destroyJSDContext(jsdc);
 236
 237     if( jsdc->userCallbacks.setContext )
 238         jsdc->userCallbacks.setContext(NULL, jsdc->user);
 239 }
 240
 241 void
 242 jsd_DebuggerPause(JSDContext* jsdc, JSBool forceAllHooksOff)
 243 {
 244     JS_SetDebuggerHandler(jsdc->jsrt, NULL, NULL);
 245     if (forceAllHooksOff || !(jsdc->flags & JSD_COLLECT_PROFILE_DATA)) {
 246         JS_SetExecuteHook(jsdc->jsrt, NULL, NULL);
 247         JS_SetCallHook(jsdc->jsrt, NULL, NULL);
 248     }
 249     JS_SetThrowHook(jsdc->jsrt, NULL, NULL);
 250     JS_SetDebugErrorHook(jsdc->jsrt, NULL, NULL);
 251 }
 252
 253 static JSBool
 254 jsd_DebugErrorHook(JSContext *cx, const char *message,
 255                    JSErrorReport *report, void *closure);
 256
 257 void
 258 jsd_DebuggerUnpause(JSDContext* jsdc)
 259 {
 260     JS_SetDebuggerHandler(jsdc->jsrt, jsd_DebuggerHandler, jsdc);
 261     JS_SetExecuteHook(jsdc->jsrt, jsd_TopLevelCallHook, jsdc);
 262     JS_SetCallHook(jsdc->jsrt, jsd_FunctionCallHook, jsdc);
 263     JS_SetThrowHook(jsdc->jsrt, jsd_ThrowHandler, jsdc);
 264     JS_SetDebugErrorHook(jsdc->jsrt, jsd_DebugErrorHook, jsdc);
 265 }
 266
 267 void
 268 jsd_SetUserCallbacks(JSRuntime* jsrt, JSD_UserCallbacks* callbacks, void* user)
 269 {
 270     _jsrt = jsrt;
 271     _user = user;
 272
 273 #ifdef JSD_HAS_DANGEROUS_THREAD
 274     _dangerousThread = JSD_CURRENT_THREAD();
 275 #endif
 276
 277     if( callbacks )
 278         memcpy(&_callbacks, callbacks, sizeof(JSD_UserCallbacks));
 279     else
 280         memset(&_callbacks, 0 , sizeof(JSD_UserCallbacks));
 281 }
 282
 283 void*
 284 jsd_SetContextPrivate(JSDContext* jsdc, void *data)
 285 {
 286     jsdc->data = data;
 287     return data;
 288 }
 289
 290 void*
 291 jsd_GetContextPrivate(JSDContext* jsdc)
 292 {
 293     return jsdc->data;
 294 }
 295
 296 void
 297 jsd_ClearAllProfileData(JSDContext* jsdc)
 298 {
 299     JSDScript *current;
 300
 301     JSD_LOCK_SCRIPTS(jsdc);
 302     current = (JSDScript *)jsdc->scripts.next;
 303     while (current != (JSDScript *)&jsdc->scripts)
 304     {
 305         jsd_ClearScriptProfileData(jsdc, current);
 306         current = (JSDScript *)current->links.next;
 307     }
 308
 309     JSD_UNLOCK_SCRIPTS(jsdc);
 310 }
 311
 312 JSDContext*
 313 jsd_JSDContextForJSContext(JSContext* context)
 314 {
 315     JSDContext* iter;
 316     JSDContext* jsdc = NULL;
 317     JSRuntime*  runtime = JS_GetRuntime(context);
 318
 319     JSD_LOCK();
 320     for( iter = (JSDContext*)_jsd_context_list.next;
 321          iter != (JSDContext*)&_jsd_context_list;
 322          iter = (JSDContext*)iter->links.next )
 323     {
 324         if( runtime == iter->jsrt )
 325         {
 326             jsdc = iter;
 327             break;
 328         }
 329     }
 330     JSD_UNLOCK();
 331     return jsdc;
 332 }
 333
 334 static JSBool
 335 jsd_DebugErrorHook(JSContext *cx, const char *message,
 336                    JSErrorReport *report, void *closure)
 337 {
 338     JSDContext* jsdc = (JSDContext*) closure;
 339     JSD_ErrorReporter errorReporter;
 340     void*             errorReporterData;
 341
 342     if( ! jsdc )
 343     {
 344         JS_ASSERT(0);
 345         return JS_TRUE;
 346     }
 347     if( JSD_IS_DANGEROUS_THREAD(jsdc) )
 348         return JS_TRUE;
 349
 350     /* local in case hook gets cleared on another thread */
 351     JSD_LOCK();
 352     errorReporter     = jsdc->errorReporter;
 353     errorReporterData = jsdc->errorReporterData;
 354     JSD_UNLOCK();
 355
 356     if(!errorReporter)
 357         return JS_TRUE;
 358
 359     switch(errorReporter(jsdc, cx, message, report, errorReporterData))
 360     {
 361         case JSD_ERROR_REPORTER_PASS_ALONG:
 362             return JS_TRUE;
 363         case JSD_ERROR_REPORTER_RETURN:
 364             return JS_FALSE;
 365         case JSD_ERROR_REPORTER_DEBUG:
 366         {
 367             jsval rval;
 368             JSD_ExecutionHookProc   hook;
 369             void*                   hookData;
 370
 371             /* local in case hook gets cleared on another thread */
 372             JSD_LOCK();
 373             hook = jsdc->debugBreakHook;
 374             hookData = jsdc->debugBreakHookData;
 375             JSD_UNLOCK();
 376
 377             jsd_CallExecutionHook(jsdc, cx, JSD_HOOK_DEBUG_REQUESTED,
 378                                   hook, hookData, &rval);
 379             /* XXX Should make this dependent on ExecutionHook retval */
 380             return JS_TRUE;
 381         }
 382         case JSD_ERROR_REPORTER_CLEAR_RETURN:
 383             if(report && JSREPORT_IS_EXCEPTION(report->flags))
 384                 JS_ClearPendingException(cx);
 385             return JS_FALSE;
 386         default:
 387             JS_ASSERT(0);
 388             break;
 389     }
 390     return JS_TRUE;
 391 }
 392
 393 JSBool
 394 jsd_SetErrorReporter(JSDContext*       jsdc,
 395                      JSD_ErrorReporter reporter,
 396                      void*             callerdata)
 397 {
 398     JSD_LOCK();
 399     jsdc->errorReporter = reporter;
 400     jsdc->errorReporterData = callerdata;
 401     JSD_UNLOCK();
 402     return JS_TRUE;
 403 }
 404
 405 JSBool
 406 jsd_GetErrorReporter(JSDContext*        jsdc,
 407                      JSD_ErrorReporter* reporter,
 408                      void**             callerdata)
 409 {
 410     JSD_LOCK();
 411     if( reporter )
 412         *reporter = jsdc->errorReporter;
 413     if( callerdata )
 414         *callerdata = jsdc->errorReporterData;
 415     JSD_UNLOCK();
 416     return JS_TRUE;
 417 }