pike.git / src / modules / _Debug / debug.cmod

version» Context lines:

pike.git/src/modules/_Debug/debug.cmod:1:   /* -*- c -*-   || This file is part of Pike. For copyright information see COPYRIGHT.   || Pike is distributed under GPL, LGPL and MPL. See the file COPYING   || for more information.   */    - #include "global.h" +    #include "module.h"   #include "pike_error.h"   #include "interpret.h"   #include "pike_embed.h"   #include "module_support.h"   #include "builtin_functions.h" - #include "mapping.h" - #include "multiset.h" +    #include "gc.h" -  + #include "opcodes.h" + #include "bignum.h"      DECLARATIONS      /*! @module Debug    */      /*! @decl int(0..) map_all_objects(function(object:void) cb)    *!    *! Call cb for all objects that currently exist. The callback will    *! not be called with destructed objects as it's argument.    *!    *! Objects might be missed if @[cb] creates new objects or destroys    *! old ones.    *!    *! This function is only intended to be used for debug purposes.    *!    *! @returns    *! The total number of objects    *!    *! @seealso -  *! @[next_object()] +  *! @[next_object()], @[find_all_clones()]    */   PIKEFUN int(0..) map_all_objects(function(object:void) cb)   {    struct object *o = first_object;    INT32 total = 0;       while( o )    {    struct object *next = o->next;    if( o->prog )
pike.git/src/modules/_Debug/debug.cmod:49:    ref_push_object( o );    safe_apply_svalue( Pike_sp-2, 1, 1 );    pop_stack();    }    total++;    o = next;    }    RETURN total;   }    + /*! @decl array(object) find_all_clones(program p, @ +  *! int(0..1)|void include_subclasses) +  *! +  *! Return an array with all objects that are clones of @[p]. +  *! +  *! @param p +  *! Program that the objects should be a clone of. +  *! +  *! @param include_subclasses +  *! If true, include also objects that are clones of programs +  *! that have inherited @[p]. Note that this adds significant +  *! overhead. +  *! +  *! This function is only intended to be used for debug purposes. +  *! +  *! @seealso +  *! @[map_all_objects()] +  */ + PIKEFUN array(object) find_all_clones(program|function prog, +  int(0..1)|void include_subclasses) + { +  struct object *o = first_object; +  struct program *p = program_from_svalue(prog); +  +  if (!p) { +  SIMPLE_ARG_TYPE_ERROR("Debug.find_all_clones", 1, "program"); +  } +  +  if (include_subclasses && !include_subclasses->u.integer) { +  include_subclasses = NULL; +  } +  +  BEGIN_AGGREGATE_ARRAY(10) { +  +  for (o = first_object; o; o = o->next) { +  if (o->prog == p) { +  ref_push_object(o); +  DO_AGGREGATE_ARRAY(120); +  continue; +  } +  if (include_subclasses && o->prog && +  (o->prog->num_inherits > p->num_inherits)) { +  int e; +  /* Check if o->prog has inherited p. */ +  if (o->prog->storage_needed < p->storage_needed) continue; +  for (e = o->prog->num_inherits + 1 - p->num_inherits; e-- > 1;) { +  if (o->prog->inherits[e].prog == p) { +  /* Found. */ +  ref_push_object(o); +  DO_AGGREGATE_ARRAY(120); +  break; +  } +  } +  } +  } +  +  } END_AGGREGATE_ARRAY; + } +    /*! @decl int refs(string|array|mapping|multiset|function|object|program o)    *!    *! Return the number of references @[o] has.    *!    *! It is mainly meant for debugging the Pike runtime, but can also be    *! used to control memory usage.    *!    *! @note    *! Note that the number of references will always be at least one since    *! the value is located on the stack when this function is executed.    *!    *! @seealso    *! @[next()], @[prev()]    */   PIKEFUN int refs(string|array|mapping|multiset|function|object|program o)   { -  +  if(!REFCOUNTED_TYPE(TYPEOF(*o))) +  SIMPLE_ARG_TYPE_ERROR("refs", 1, +  "array|mapping|multiset|object|" +  "function|program|string|type");    RETURN o->u.refs[0];   }      /*! @decl object next_object(object o)    *! @decl object next_object()    *!    *! Returns the next object from the list of all objects.    *!    *! All objects are stored in a linked list.    *!
pike.git/src/modules/_Debug/debug.cmod:492:      /*! @decl void dump_dmalloc_locations(string|array|mapping| @    *! multiset|function|object| @    *! program|type o)    *!    *! @note    *! Only available when compiled with dmalloc.    */   PIKEFUN void dump_dmalloc_locations(string|array|mapping|multiset|function|object|program|type o)   { +  if(!REFCOUNTED_TYPE(TYPEOF(*o))) +  SIMPLE_ARG_TYPE_ERROR("refs", 1, +  "array|mapping|multiset|object|" +  "function|program|string|type");    debug_malloc_dump_references (o->u.refs, 2, 1, 0);   }   #endif /* DEBUG_MALLOC */      /*! @decl mapping(string:int) get_program_layout(program p)    *! Returns a mapping which describes the layout of compiled machine    *! code in the program @expr{p@}. The indices of the returned mapping    *! are function names, the values the starting address of the compiled    *! function. The total size of the program code is stored with index    *! @expr{0@}.
pike.git/src/modules/_Debug/debug.cmod:517:    if(p->flags & PROGRAM_FINISHED) {    for (i = 0; i < p->num_identifier_references; i++) {    struct reference *ref = p->identifier_references + i;    struct identifier *id = ID_FROM_PTR(p, ref);       if ((id->identifier_flags & IDENTIFIER_TYPE_MASK)    == IDENTIFIER_PIKE_FUNCTION    && !ref->inherit_offset) {    PIKE_OPCODE_T *pc = p->program + id->func.offset;    struct svalue sv; -  SET_SVAL(sv, PIKE_T_INT, NUMBER_NUMBER, integer, PTR_TO_INT(pc)); +  +  ulongest_to_svalue_no_free(&sv, (UINT64)PTR_TO_INT(pc)); +     mapping_string_insert(m, id->name, &sv); -  +  free_svalue(&sv);    }    }       {    struct svalue key, value;       SET_SVAL(key, PIKE_T_INT, NUMBER_NUMBER, integer, 0);    SET_SVAL(value, PIKE_T_INT, NUMBER_NUMBER, integer,    p->num_program * sizeof(PIKE_OPCODE_T));    mapping_insert(m, &key, &value);