src/v8/tools/gen-postmortem-metadata.py

   1 #!/usr/bin/env python
   2
   3 #
   4 # Copyright 2012 the V8 project authors. All rights reserved.
   5 # Redistribution and use in source and binary forms, with or without
   6 # modification, are permitted provided that the following conditions are
   7 # met:
   8 #
   9 #     * Redistributions of source code must retain the above copyright
  10 #       notice, this list of conditions and the following disclaimer.
  11 #     * Redistributions in binary form must reproduce the above
  12 #       copyright notice, this list of conditions and the following
  13 #       disclaimer in the documentation and/or other materials provided
  14 #       with the distribution.
  15 #     * Neither the name of Google Inc. nor the names of its
  16 #       contributors may be used to endorse or promote products derived
  17 #       from this software without specific prior written permission.
  18 #
  19 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30 #
  31
  32 #
  33 # Emits a C++ file to be compiled and linked into libv8 to support postmortem
  34 # debugging tools.  Most importantly, this tool emits constants describing V8
  35 # internals:
  36 #
  37 #    v8dbg_type_CLASS__TYPE = VALUE             Describes class type values
  38 #    v8dbg_class_CLASS__FIELD__TYPE = OFFSET    Describes class fields
  39 #    v8dbg_parent_CLASS__PARENT                 Describes class hierarchy
  40 #    v8dbg_frametype_NAME = VALUE               Describes stack frame values
  41 #    v8dbg_off_fp_NAME = OFFSET                 Frame pointer offsets
  42 #    v8dbg_prop_NAME = OFFSET                   Object property offsets
  43 #    v8dbg_NAME = VALUE                         Miscellaneous values
  44 #
  45 # These constants are declared as global integers so that they'll be present in
  46 # the generated libv8 binary.
  47 #
  48
  49 import re
  50 import sys
  51
  52 #
  53 # Miscellaneous constants, tags, and masks used for object identification.
  54 #
  55 consts_misc = [
  56     { 'name': 'FirstNonstringType',     'value': 'FIRST_NONSTRING_TYPE' },
  57
  58     { 'name': 'IsNotStringMask',        'value': 'kIsNotStringMask' },
  59     { 'name': 'StringTag',              'value': 'kStringTag' },
  60     { 'name': 'NotStringTag',           'value': 'kNotStringTag' },
  61
  62     { 'name': 'StringEncodingMask',     'value': 'kStringEncodingMask' },
  63     { 'name': 'TwoByteStringTag',       'value': 'kTwoByteStringTag' },
  64     { 'name': 'AsciiStringTag',         'value': 'kOneByteStringTag' },
  65
  66     { 'name': 'StringRepresentationMask',
  67         'value': 'kStringRepresentationMask' },
  68     { 'name': 'SeqStringTag',           'value': 'kSeqStringTag' },
  69     { 'name': 'ConsStringTag',          'value': 'kConsStringTag' },
  70     { 'name': 'ExternalStringTag',      'value': 'kExternalStringTag' },
  71     { 'name': 'SlicedStringTag',        'value': 'kSlicedStringTag' },
  72
  73     { 'name': 'FailureTag',             'value': 'kFailureTag' },
  74     { 'name': 'FailureTagMask',         'value': 'kFailureTagMask' },
  75     { 'name': 'HeapObjectTag',          'value': 'kHeapObjectTag' },
  76     { 'name': 'HeapObjectTagMask',      'value': 'kHeapObjectTagMask' },
  77     { 'name': 'SmiTag',                 'value': 'kSmiTag' },
  78     { 'name': 'SmiTagMask',             'value': 'kSmiTagMask' },
  79     { 'name': 'SmiValueShift',          'value': 'kSmiTagSize' },
  80     { 'name': 'SmiShiftSize',           'value': 'kSmiShiftSize' },
  81     { 'name': 'PointerSizeLog2',        'value': 'kPointerSizeLog2' },
  82
  83     { 'name': 'prop_idx_first',
  84         'value': 'DescriptorArray::kFirstIndex' },
  85     { 'name': 'prop_type_field',
  86         'value': 'FIELD' },
  87     { 'name': 'prop_type_first_phantom',
  88         'value': 'TRANSITION' },
  89     { 'name': 'prop_type_mask',
  90         'value': 'PropertyDetails::TypeField::kMask' },
  91
  92     { 'name': 'prop_desc_key',
  93         'value': 'DescriptorArray::kDescriptorKey' },
  94     { 'name': 'prop_desc_details',
  95         'value': 'DescriptorArray::kDescriptorDetails' },
  96     { 'name': 'prop_desc_value',
  97         'value': 'DescriptorArray::kDescriptorValue' },
  98     { 'name': 'prop_desc_size',
  99         'value': 'DescriptorArray::kDescriptorSize' },
 100
 101     { 'name': 'off_fp_context',
 102         'value': 'StandardFrameConstants::kContextOffset' },
 103     { 'name': 'off_fp_constant_pool',
 104         'value': 'StandardFrameConstants::kConstantPoolOffset' },
 105     { 'name': 'off_fp_marker',
 106         'value': 'StandardFrameConstants::kMarkerOffset' },
 107     { 'name': 'off_fp_function',
 108         'value': 'JavaScriptFrameConstants::kFunctionOffset' },
 109     { 'name': 'off_fp_args',
 110         'value': 'JavaScriptFrameConstants::kLastParameterOffset' },
 111 ];
 112
 113 #
 114 # The following useful fields are missing accessors, so we define fake ones.
 115 #
 116 extras_accessors = [
 117     'HeapObject, map, Map, kMapOffset',
 118     'JSObject, elements, Object, kElementsOffset',
 119     'FixedArray, data, uintptr_t, kHeaderSize',
 120     'Map, instance_attributes, int, kInstanceAttributesOffset',
 121     'Map, inobject_properties, int, kInObjectPropertiesOffset',
 122     'Map, instance_size, int, kInstanceSizeOffset',
 123     'HeapNumber, value, double, kValueOffset',
 124     'ConsString, first, String, kFirstOffset',
 125     'ConsString, second, String, kSecondOffset',
 126     'ExternalString, resource, Object, kResourceOffset',
 127     'SeqOneByteString, chars, char, kHeaderSize',
 128     'SeqTwoByteString, chars, char, kHeaderSize',
 129     'SharedFunctionInfo, code, Code, kCodeOffset',
 130     'SlicedString, parent, String, kParentOffset',
 131     'Code, instruction_start, uintptr_t, kHeaderSize',
 132     'Code, instruction_size, int, kInstructionSizeOffset',
 133 ];
 134
 135 #
 136 # The following is a whitelist of classes we expect to find when scanning the
 137 # source code. This list is not exhaustive, but it's still useful to identify
 138 # when this script gets out of sync with the source. See load_objects().
 139 #
 140 expected_classes = [
 141     'ConsString', 'FixedArray', 'HeapNumber', 'JSArray', 'JSFunction',
 142     'JSObject', 'JSRegExp', 'JSValue', 'Map', 'Oddball', 'Script',
 143     'SeqOneByteString', 'SharedFunctionInfo'
 144 ];
 145
 146
 147 #
 148 # The following structures store high-level representations of the structures
 149 # for which we're going to emit descriptive constants.
 150 #
 151 types = {};             # set of all type names
 152 typeclasses = {};       # maps type names to corresponding class names
 153 klasses = {};           # known classes, including parents
 154 fields = [];            # field declarations
 155
 156 header = '''
 157 /*
 158  * This file is generated by %s.  Do not edit directly.
 159  */
 160
 161 #include "v8.h"
 162 #include "frames.h"
 163 #include "frames-inl.h" /* for architecture-specific frame constants */
 164
 165 using namespace v8::internal;
 166
 167 extern "C" {
 168
 169 /* stack frame constants */
 170 #define FRAME_CONST(value, klass)       \
 171     int v8dbg_frametype_##klass = StackFrame::value;
 172
 173 STACK_FRAME_TYPE_LIST(FRAME_CONST)
 174
 175 #undef FRAME_CONST
 176
 177 ''' % sys.argv[0];
 178
 179 footer = '''
 180 }
 181 '''
 182
 183 #
 184 # Loads class hierarchy and type information from "objects.h".
 185 #
 186 def load_objects():
 187         objfilename = sys.argv[2];
 188         objfile = open(objfilename, 'r');
 189         in_insttype = False;
 190
 191         typestr = '';
 192
 193         #
 194         # Construct a dictionary for the classes we're sure should be present.
 195         #
 196         checktypes = {};
 197         for klass in expected_classes:
 198                 checktypes[klass] = True;
 199
 200         #
 201         # Iterate objects.h line-by-line to collect type and class information.
 202         # For types, we accumulate a string representing the entire InstanceType
 203         # enum definition and parse it later because it's easier to do so
 204         # without the embedded newlines.
 205         #
 206         for line in objfile:
 207                 if (line.startswith('enum InstanceType {')):
 208                         in_insttype = True;
 209                         continue;
 210
 211                 if (in_insttype and line.startswith('};')):
 212                         in_insttype = False;
 213                         continue;
 214
 215                 line = re.sub('//.*', '', line.rstrip().lstrip());
 216
 217                 if (in_insttype):
 218                         typestr += line;
 219                         continue;
 220
 221                 match = re.match('class (\w[^\s:]*)(: public (\w[^\s{]*))?\s*{',
 222                     line);
 223
 224                 if (match):
 225                         klass = match.group(1);
 226                         pklass = match.group(3);
 227                         klasses[klass] = { 'parent': pklass };
 228
 229         #
 230         # Process the instance type declaration.
 231         #
 232         entries = typestr.split(',');
 233         for entry in entries:
 234                 types[re.sub('\s*=.*', '', entry).lstrip()] = True;
 235
 236         #
 237         # Infer class names for each type based on a systematic transformation.
 238         # For example, "JS_FUNCTION_TYPE" becomes "JSFunction".  We find the
 239         # class for each type rather than the other way around because there are
 240         # fewer cases where one type maps to more than one class than the other
 241         # way around.
 242         #
 243         for type in types:
 244                 #
 245                 # Symbols and Strings are implemented using the same classes.
 246                 #
 247                 usetype = re.sub('SYMBOL_', 'STRING_', type);
 248
 249                 #
 250                 # REGEXP behaves like REG_EXP, as in JS_REGEXP_TYPE => JSRegExp.
 251                 #
 252                 usetype = re.sub('_REGEXP_', '_REG_EXP_', usetype);
 253
 254                 #
 255                 # Remove the "_TYPE" suffix and then convert to camel case,
 256                 # except that a "JS" prefix remains uppercase (as in
 257                 # "JS_FUNCTION_TYPE" => "JSFunction").
 258                 #
 259                 if (not usetype.endswith('_TYPE')):
 260                         continue;
 261
 262                 usetype = usetype[0:len(usetype) - len('_TYPE')];
 263                 parts = usetype.split('_');
 264                 cctype = '';
 265
 266                 if (parts[0] == 'JS'):
 267                         cctype = 'JS';
 268                         start = 1;
 269                 else:
 270                         cctype = '';
 271                         start = 0;
 272
 273                 for ii in range(start, len(parts)):
 274                         part = parts[ii];
 275                         cctype += part[0].upper() + part[1:].lower();
 276
 277                 #
 278                 # Mapping string types is more complicated.  Both types and
 279                 # class names for Strings specify a representation (e.g., Seq,
 280                 # Cons, External, or Sliced) and an encoding (TwoByte or Ascii),
 281                 # In the simplest case, both of these are explicit in both
 282                 # names, as in:
 283                 #
 284                 #       EXTERNAL_ASCII_STRING_TYPE => ExternalAsciiString
 285                 #
 286                 # However, either the representation or encoding can be omitted
 287                 # from the type name, in which case "Seq" and "TwoByte" are
 288                 # assumed, as in:
 289                 #
 290                 #       STRING_TYPE => SeqTwoByteString
 291                 #
 292                 # Additionally, sometimes the type name has more information
 293                 # than the class, as in:
 294                 #
 295                 #       CONS_ASCII_STRING_TYPE => ConsString
 296                 #
 297                 # To figure this out dynamically, we first check for a
 298                 # representation and encoding and add them if they're not
 299                 # present.  If that doesn't yield a valid class name, then we
 300                 # strip out the representation.
 301                 #
 302                 if (cctype.endswith('String')):
 303                         if (cctype.find('Cons') == -1 and
 304                             cctype.find('External') == -1 and
 305                             cctype.find('Sliced') == -1):
 306                                 if (cctype.find('Ascii') != -1):
 307                                         cctype = re.sub('AsciiString$',
 308                                             'SeqOneByteString', cctype);
 309                                 else:
 310                                         cctype = re.sub('String$',
 311                                             'SeqString', cctype);
 312
 313                         if (cctype.find('Ascii') == -1):
 314                                 cctype = re.sub('String$', 'TwoByteString',
 315                                     cctype);
 316
 317                         if (not (cctype in klasses)):
 318                                 cctype = re.sub('Ascii', '', cctype);
 319                                 cctype = re.sub('TwoByte', '', cctype);
 320
 321                 #
 322                 # Despite all that, some types have no corresponding class.
 323                 #
 324                 if (cctype in klasses):
 325                         typeclasses[type] = cctype;
 326                         if (cctype in checktypes):
 327                                 del checktypes[cctype];
 328
 329         if (len(checktypes) > 0):
 330                 for klass in checktypes:
 331                         print('error: expected class \"%s\" not found' % klass);
 332
 333                 sys.exit(1);
 334
 335
 336 #
 337 # For a given macro call, pick apart the arguments and return an object
 338 # describing the corresponding output constant.  See load_fields().
 339 #
 340 def parse_field(call):
 341         # Replace newlines with spaces.
 342         for ii in range(0, len(call)):
 343                 if (call[ii] == '\n'):
 344                         call[ii] == ' ';
 345
 346         idx = call.find('(');
 347         kind = call[0:idx];
 348         rest = call[idx + 1: len(call) - 1];
 349         args = re.split('\s*,\s*', rest);
 350
 351         consts = [];
 352
 353         if (kind == 'ACCESSORS' or kind == 'ACCESSORS_GCSAFE'):
 354                 klass = args[0];
 355                 field = args[1];
 356                 dtype = args[2];
 357                 offset = args[3];
 358
 359                 return ({
 360                     'name': 'class_%s__%s__%s' % (klass, field, dtype),
 361                     'value': '%s::%s' % (klass, offset)
 362                 });
 363
 364         assert(kind == 'SMI_ACCESSORS');
 365         klass = args[0];
 366         field = args[1];
 367         offset = args[2];
 368
 369         return ({
 370             'name': 'class_%s__%s__%s' % (klass, field, 'SMI'),
 371             'value': '%s::%s' % (klass, offset)
 372         });
 373
 374 #
 375 # Load field offset information from objects-inl.h.
 376 #
 377 def load_fields():
 378         inlfilename = sys.argv[3];
 379         inlfile = open(inlfilename, 'r');
 380
 381         #
 382         # Each class's fields and the corresponding offsets are described in the
 383         # source by calls to macros like "ACCESSORS" (and friends).  All we do
 384         # here is extract these macro invocations, taking into account that they
 385         # may span multiple lines and may contain nested parentheses.  We also
 386         # call parse_field() to pick apart the invocation.
 387         #
 388         prefixes = [ 'ACCESSORS', 'ACCESSORS_GCSAFE', 'SMI_ACCESSORS' ];
 389         current = '';
 390         opens = 0;
 391
 392         for line in inlfile:
 393                 if (opens > 0):
 394                         # Continuation line
 395                         for ii in range(0, len(line)):
 396                                 if (line[ii] == '('):
 397                                         opens += 1;
 398                                 elif (line[ii] == ')'):
 399                                         opens -= 1;
 400
 401                                 if (opens == 0):
 402                                         break;
 403
 404                         current += line[0:ii + 1];
 405                         continue;
 406
 407                 for prefix in prefixes:
 408                         if (not line.startswith(prefix + '(')):
 409                                 continue;
 410
 411                         if (len(current) > 0):
 412                                 fields.append(parse_field(current));
 413                                 current = '';
 414
 415                         for ii in range(len(prefix), len(line)):
 416                                 if (line[ii] == '('):
 417                                         opens += 1;
 418                                 elif (line[ii] == ')'):
 419                                         opens -= 1;
 420
 421                                 if (opens == 0):
 422                                         break;
 423
 424                         current += line[0:ii + 1];
 425
 426         if (len(current) > 0):
 427                 fields.append(parse_field(current));
 428                 current = '';
 429
 430         for body in extras_accessors:
 431                 fields.append(parse_field('ACCESSORS(%s)' % body));
 432
 433 #
 434 # Emit a block of constants.
 435 #
 436 def emit_set(out, consts):
 437         # Fix up overzealous parses.  This could be done inside the
 438         # parsers but as there are several, it's easiest to do it here.
 439         ws = re.compile('\s+')
 440         for const in consts:
 441                 name = ws.sub('', const['name'])
 442                 value = ws.sub('', str(const['value']))  # Can be a number.
 443                 out.write('int v8dbg_%s = %s;\n' % (name, value))
 444         out.write('\n');
 445
 446 #
 447 # Emit the whole output file.
 448 #
 449 def emit_config():
 450         out = file(sys.argv[1], 'w');
 451
 452         out.write(header);
 453
 454         out.write('/* miscellaneous constants */\n');
 455         emit_set(out, consts_misc);
 456
 457         out.write('/* class type information */\n');
 458         consts = [];
 459         keys = typeclasses.keys();
 460         keys.sort();
 461         for typename in keys:
 462                 klass = typeclasses[typename];
 463                 consts.append({
 464                     'name': 'type_%s__%s' % (klass, typename),
 465                     'value': typename
 466                 });
 467
 468         emit_set(out, consts);
 469
 470         out.write('/* class hierarchy information */\n');
 471         consts = [];
 472         keys = klasses.keys();
 473         keys.sort();
 474         for klassname in keys:
 475                 pklass = klasses[klassname]['parent'];
 476                 if (pklass == None):
 477                         continue;
 478
 479                 consts.append({
 480                     'name': 'parent_%s__%s' % (klassname, pklass),
 481                     'value': 0
 482                 });
 483
 484         emit_set(out, consts);
 485
 486         out.write('/* field information */\n');
 487         emit_set(out, fields);
 488
 489         out.write(footer);
 490
 491 if (len(sys.argv) < 4):
 492         print('usage: %s output.cc objects.h objects-inl.h' % sys.argv[0]);
 493         sys.exit(2);
 494
 495 load_objects();
 496 load_fields();
 497 emit_config();