gen-postmortem-metadata.py 26.5 KB
Newer Older
1
#!/usr/bin/env python3
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

#
# Copyright 2012 the V8 project authors. All rights reserved.
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
#     * Redistributions of source code must retain the above copyright
#       notice, this list of conditions and the following disclaimer.
#     * Redistributions in binary form must reproduce the above
#       copyright notice, this list of conditions and the following
#       disclaimer in the documentation and/or other materials provided
#       with the distribution.
#     * Neither the name of Google Inc. nor the names of its
#       contributors may be used to endorse or promote products derived
#       from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#

#
# Emits a C++ file to be compiled and linked into libv8 to support postmortem
# debugging tools.  Most importantly, this tool emits constants describing V8
# internals:
#
#    v8dbg_type_CLASS__TYPE = VALUE             Describes class type values
#    v8dbg_class_CLASS__FIELD__TYPE = OFFSET    Describes class fields
#    v8dbg_parent_CLASS__PARENT                 Describes class hierarchy
#    v8dbg_frametype_NAME = VALUE               Describes stack frame values
#    v8dbg_off_fp_NAME = OFFSET                 Frame pointer offsets
#    v8dbg_prop_NAME = OFFSET                   Object property offsets
#    v8dbg_NAME = VALUE                         Miscellaneous values
#
# These constants are declared as global integers so that they'll be present in
# the generated libv8 binary.
#

49 50 51
# for py2/py3 compatibility
from __future__ import print_function

52
import io
53 54 55 56
import re
import sys

#
57 58
# Miscellaneous constants such as tags and masks used for object identification,
# enumeration values used as indexes in internal tables, etc..
59 60 61
#
consts_misc = [
    { 'name': 'FirstNonstringType',     'value': 'FIRST_NONSTRING_TYPE' },
62
    { 'name': 'APIObjectType',    'value': 'JS_API_OBJECT_TYPE' },
63
    { 'name': 'SpecialAPIObjectType',   'value': 'JS_SPECIAL_API_OBJECT_TYPE' },
64

65 66 67
    { 'name': 'FirstContextType',     'value': 'FIRST_CONTEXT_TYPE' },
    { 'name': 'LastContextType',     'value': 'LAST_CONTEXT_TYPE' },

68 69
    { 'name': 'IsNotStringMask',  'value': 'kIsNotStringMask' },
    { 'name': 'StringTag',        'value': 'kStringTag' },
70 71 72

    { 'name': 'StringEncodingMask',     'value': 'kStringEncodingMask' },
    { 'name': 'TwoByteStringTag',       'value': 'kTwoByteStringTag' },
73
    { 'name': 'OneByteStringTag',       'value': 'kOneByteStringTag' },
74 75

    { 'name': 'StringRepresentationMask',
76 77 78
  'value': 'kStringRepresentationMask' },
    { 'name': 'SeqStringTag',     'value': 'kSeqStringTag' },
    { 'name': 'ConsStringTag',    'value': 'kConsStringTag' },
79
    { 'name': 'ExternalStringTag',      'value': 'kExternalStringTag' },
80 81
    { 'name': 'SlicedStringTag',  'value': 'kSlicedStringTag' },
    { 'name': 'ThinStringTag',    'value': 'kThinStringTag' },
82

83
    { 'name': 'HeapObjectTag',    'value': 'kHeapObjectTag' },
84
    { 'name': 'HeapObjectTagMask',      'value': 'kHeapObjectTagMask' },
85 86 87 88
    { 'name': 'SmiTag',     'value': 'kSmiTag' },
    { 'name': 'SmiTagMask',       'value': 'kSmiTagMask' },
    { 'name': 'SmiValueShift',    'value': 'kSmiTagSize' },
    { 'name': 'SmiShiftSize',     'value': 'kSmiShiftSize' },
89 90
    { 'name': 'SystemPointerSize',      'value': 'kSystemPointerSize' },
    { 'name': 'SystemPointerSizeLog2',  'value': 'kSystemPointerSizeLog2' },
91 92
    { 'name': 'TaggedSize',       'value': 'kTaggedSize' },
    { 'name': 'TaggedSizeLog2',   'value': 'kTaggedSizeLog2' },
93

94 95 96 97 98 99 100 101 102 103
    { 'name': 'CodeKindFieldMask',      'value': 'Code::KindField::kMask' },
    { 'name': 'CodeKindFieldShift',     'value': 'Code::KindField::kShift' },

    { 'name': 'CodeKindBytecodeHandler',
      'value': 'static_cast<int>(CodeKind::BYTECODE_HANDLER)' },
    { 'name': 'CodeKindInterpretedFunction',
      'value': 'static_cast<int>(CodeKind::INTERPRETED_FUNCTION)' },
    { 'name': 'CodeKindBaseline',
      'value': 'static_cast<int>(CodeKind::BASELINE)' },

104 105 106 107
    { 'name': 'OddballFalse',     'value': 'Oddball::kFalse' },
    { 'name': 'OddballTrue',      'value': 'Oddball::kTrue' },
    { 'name': 'OddballTheHole',   'value': 'Oddball::kTheHole' },
    { 'name': 'OddballNull',      'value': 'Oddball::kNull' },
108
    { 'name': 'OddballArgumentsMarker', 'value': 'Oddball::kArgumentsMarker' },
109 110
    { 'name': 'OddballUndefined',       'value': 'Oddball::kUndefined' },
    { 'name': 'OddballUninitialized',   'value': 'Oddball::kUninitialized' },
111
    { 'name': 'OddballOther',     'value': 'Oddball::kOther' },
112 113
    { 'name': 'OddballException',       'value': 'Oddball::kException' },

114 115
    { 'name': 'ContextRegister',  'value': 'kContextRegister.code()' },
    { 'name': 'ReturnRegister0',  'value': 'kReturnRegister0.code()' },
116 117 118 119 120 121 122 123
    { 'name': 'JSFunctionRegister',     'value': 'kJSFunctionRegister.code()' },
    { 'name': 'InterpreterBytecodeOffsetRegister',
      'value': 'kInterpreterBytecodeOffsetRegister.code()' },
    { 'name': 'InterpreterBytecodeArrayRegister',
      'value': 'kInterpreterBytecodeArrayRegister.code()' },
    { 'name': 'RuntimeCallFunctionRegister',
      'value': 'kRuntimeCallFunctionRegister.code()' },

124
    { 'name': 'prop_kind_Data',
125
  'value': 'static_cast<int>(PropertyKind::kData)' },
126
    { 'name': 'prop_kind_Accessor',
127
  'value': 'static_cast<int>(PropertyKind::kAccessor)' },
128
    { 'name': 'prop_kind_mask',
129
  'value': 'PropertyDetails::KindField::kMask' },
130
    { 'name': 'prop_location_Descriptor',
131
  'value': 'static_cast<int>(PropertyLocation::kDescriptor)' },
132
    { 'name': 'prop_location_Field',
133
  'value': 'static_cast<int>(PropertyLocation::kField)' },
134
    { 'name': 'prop_location_mask',
135
  'value': 'PropertyDetails::LocationField::kMask' },
136
    { 'name': 'prop_location_shift',
137
  'value': 'PropertyDetails::LocationField::kShift' },
138 139 140 141 142
    { 'name': 'prop_attributes_NONE', 'value': 'NONE' },
    { 'name': 'prop_attributes_READ_ONLY', 'value': 'READ_ONLY' },
    { 'name': 'prop_attributes_DONT_ENUM', 'value': 'DONT_ENUM' },
    { 'name': 'prop_attributes_DONT_DELETE', 'value': 'DONT_DELETE' },
    { 'name': 'prop_attributes_mask',
143
  'value': 'PropertyDetails::AttributesField::kMask' },
144
    { 'name': 'prop_attributes_shift',
145
  'value': 'PropertyDetails::AttributesField::kShift' },
146
    { 'name': 'prop_index_mask',
147
  'value': 'PropertyDetails::FieldIndexField::kMask' },
148
    { 'name': 'prop_index_shift',
149
  'value': 'PropertyDetails::FieldIndexField::kShift' },
150
    { 'name': 'prop_representation_mask',
151
  'value': 'PropertyDetails::RepresentationField::kMask' },
152
    { 'name': 'prop_representation_shift',
153
  'value': 'PropertyDetails::RepresentationField::kShift' },
154
    { 'name': 'prop_representation_smi',
155
  'value': 'Representation::Kind::kSmi' },
156
    { 'name': 'prop_representation_double',
157
  'value': 'Representation::Kind::kDouble' },
158
    { 'name': 'prop_representation_heapobject',
159
  'value': 'Representation::Kind::kHeapObject' },
160
    { 'name': 'prop_representation_tagged',
161
  'value': 'Representation::Kind::kTagged' },
162

163
    { 'name': 'prop_desc_key',
164
  'value': 'DescriptorArray::kEntryKeyIndex' },
165
    { 'name': 'prop_desc_details',
166
  'value': 'DescriptorArray::kEntryDetailsIndex' },
167
    { 'name': 'prop_desc_value',
168
  'value': 'DescriptorArray::kEntryValueIndex' },
169
    { 'name': 'prop_desc_size',
170
  'value': 'DescriptorArray::kEntrySize' },
171

172
    { 'name': 'elements_fast_holey_elements',
173
  'value': 'HOLEY_ELEMENTS' },
174
    { 'name': 'elements_fast_elements',
175
  'value': 'PACKED_ELEMENTS' },
176
    { 'name': 'elements_dictionary_elements',
177
  'value': 'DICTIONARY_ELEMENTS' },
178 179

    { 'name': 'bit_field2_elements_kind_mask',
180
  'value': 'Map::Bits2::ElementsKindBits::kMask' },
181
    { 'name': 'bit_field2_elements_kind_shift',
182
  'value': 'Map::Bits2::ElementsKindBits::kShift' },
183
    { 'name': 'bit_field3_is_dictionary_map_shift',
184
  'value': 'Map::Bits3::IsDictionaryMapBit::kShift' },
185
    { 'name': 'bit_field3_number_of_own_descriptors_mask',
186
  'value': 'Map::Bits3::NumberOfOwnDescriptorsBits::kMask' },
187
    { 'name': 'bit_field3_number_of_own_descriptors_shift',
188
  'value': 'Map::Bits3::NumberOfOwnDescriptorsBits::kShift' },
189
    { 'name': 'class_Map__instance_descriptors_offset',
190
  'value': 'Map::kInstanceDescriptorsOffset' },
191

192
    { 'name': 'off_fp_context_or_frame_type',
193
  'value': 'CommonFrameConstants::kContextOrFrameTypeOffset'},
194
    { 'name': 'off_fp_context',
195
  'value': 'StandardFrameConstants::kContextOffset' },
196
    { 'name': 'off_fp_constant_pool',
197
  'value': 'StandardFrameConstants::kConstantPoolOffset' },
198
    { 'name': 'off_fp_function',
199
  'value': 'StandardFrameConstants::kFunctionOffset' },
200
    { 'name': 'off_fp_args',
201
  'value': 'StandardFrameConstants::kFixedFrameSizeAboveFp' },
202
    { 'name': 'off_fp_bytecode_array',
203
  'value': 'UnoptimizedFrameConstants::kBytecodeArrayFromFp' },
204
    { 'name': 'off_fp_bytecode_offset',
205
  'value': 'UnoptimizedFrameConstants::kBytecodeOffsetOrFeedbackVectorFromFp' },
206 207

    { 'name': 'scopeinfo_idx_nparams',
208
  'value': 'ScopeInfo::kParameterCount' },
209
    { 'name': 'scopeinfo_idx_ncontextlocals',
210
  'value': 'ScopeInfo::kContextLocalCount' },
211
    { 'name': 'scopeinfo_idx_first_vars',
212
  'value': 'ScopeInfo::kVariablePartIndex' },
213

214
    { 'name': 'jsarray_buffer_was_detached_mask',
215
  'value': 'JSArrayBuffer::WasDetachedBit::kMask' },
216
    { 'name': 'jsarray_buffer_was_detached_shift',
217
  'value': 'JSArrayBuffer::WasDetachedBit::kShift' },
218

219
    { 'name': 'context_idx_scope_info',
220
  'value': 'Context::SCOPE_INFO_INDEX' },
221
    { 'name': 'context_idx_prev',
222
  'value': 'Context::PREVIOUS_INDEX' },
223
    { 'name': 'context_min_slots',
224
  'value': 'Context::MIN_CONTEXT_SLOTS' },
225
    { 'name': 'native_context_embedder_data_offset',
226
  'value': 'Internals::kNativeContextEmbedderDataOffset' },
227

228 229

    { 'name': 'namedictionaryshape_prefix_size',
230
  'value': 'NameDictionaryShape::kPrefixSize' },
231
    { 'name': 'namedictionaryshape_entry_size',
232
  'value': 'NameDictionaryShape::kEntrySize' },
233
    { 'name': 'globaldictionaryshape_entry_size',
234
  'value': 'GlobalDictionaryShape::kEntrySize' },
235 236

    { 'name': 'namedictionary_prefix_start_index',
237
  'value': 'NameDictionary::kPrefixStartIndex' },
238

239
    { 'name': 'numberdictionaryshape_prefix_size',
240
  'value': 'NumberDictionaryShape::kPrefixSize' },
241
    { 'name': 'numberdictionaryshape_entry_size',
242
  'value': 'NumberDictionaryShape::kEntrySize' },
243 244

    { 'name': 'simplenumberdictionaryshape_prefix_size',
245
  'value': 'SimpleNumberDictionaryShape::kPrefixSize' },
246
    { 'name': 'simplenumberdictionaryshape_entry_size',
247
  'value': 'SimpleNumberDictionaryShape::kEntrySize' },
248 249

    { 'name': 'type_JSError__JS_ERROR_TYPE', 'value': 'JS_ERROR_TYPE' },
250 251 252 253
];

#
# The following useful fields are missing accessors, so we define fake ones.
254 255 256 257 258
# Please note that extra accessors should _only_ be added to expose offsets that
# can be used to access actual V8 objects' properties. They should not be added
# for exposing other values. For instance, enumeration values or class'
# constants should be exposed by adding an entry in the "consts_misc" table, not
# in this "extras_accessors" table.
259 260
#
extras_accessors = [
261
    'JSFunction, context, Context, kContextOffset',
262
    'JSFunction, shared, SharedFunctionInfo, kSharedFunctionInfoOffset',
263 264
    'HeapObject, map, Map, kMapOffset',
    'JSObject, elements, Object, kElementsOffset',
265
    'JSObject, internal_fields, uintptr_t, kHeaderSize',
266
    'FixedArray, data, uintptr_t, kHeaderSize',
267
    'BytecodeArray, data, uintptr_t, kHeaderSize',
268
    'JSArrayBuffer, backing_store, uintptr_t, kBackingStoreOffset',
269 270 271
    'JSArrayBuffer, byte_length, size_t, kByteLengthOffset',
    'JSArrayBufferView, byte_length, size_t, kByteLengthOffset',
    'JSArrayBufferView, byte_offset, size_t, kByteOffsetOffset',
272 273
    'JSDate, value, Object, kValueOffset',
    'JSRegExp, source, Object, kSourceOffset',
274
    'JSTypedArray, external_pointer, uintptr_t, kExternalPointerOffset',
275
    'JSTypedArray, length, Object, kLengthOffset',
276
    'Map, instance_size_in_words, char, kInstanceSizeInWordsOffset',
277
    'Map, inobject_properties_start_or_constructor_function_index, char, kInobjectPropertiesStartOrConstructorFunctionIndexOffset',
278
    'Map, instance_type, uint16_t, kInstanceTypeOffset',
279 280
    'Map, bit_field, char, kBitFieldOffset',
    'Map, bit_field2, char, kBitField2Offset',
281
    'Map, bit_field3, int, kBitField3Offset',
282 283
    'Map, prototype, Object, kPrototypeOffset',
    'Oddball, kind_offset, int, kKindOffset',
284 285
    'HeapNumber, value, double, kValueOffset',
    'ExternalString, resource, Object, kResourceOffset',
286
    'SeqOneByteString, chars, char, kHeaderSize',
287
    'SeqTwoByteString, chars, char, kHeaderSize',
288
    'UncompiledData, inferred_name, String, kInferredNameOffset',
289 290
    'UncompiledData, start_position, int32_t, kStartPositionOffset',
    'UncompiledData, end_position, int32_t, kEndPositionOffset',
291
    'Script, source, Object, kSourceOffset',
292 293
    'Script, name, Object, kNameOffset',
    'Script, line_ends, Object, kLineEndsOffset',
294
    'SharedFunctionInfo, raw_function_token_offset, int16_t, kFunctionTokenOffsetOffset',
295
    'SharedFunctionInfo, internal_formal_parameter_count, uint16_t, kFormalParameterCountOffset',
296
    'SharedFunctionInfo, flags, int, kFlagsOffset',
297
    'SharedFunctionInfo, length, uint16_t, kLengthOffset',
298
    'SlicedString, parent, String, kParentOffset',
299
    'Code, flags, uint32_t, kFlagsOffset',
300 301
    'Code, instruction_start, uintptr_t, kHeaderSize',
    'Code, instruction_size, int, kInstructionSizeOffset',
302
    'String, length, int32_t, kLengthOffset',
303
    'DescriptorArray, header_size, uintptr_t, kHeaderSize',
304 305 306 307
    'ConsString, first, String, kFirstOffset',
    'ConsString, second, String, kSecondOffset',
    'SlicedString, offset, SMI, kOffsetOffset',
    'ThinString, actual, String, kActualOffset',
308
    'Symbol, name, Object, kDescriptionOffset',
309
    'FixedArrayBase, length, SMI, kLengthOffset',
310 311 312 313 314 315 316 317 318
];

#
# The following is a whitelist of classes we expect to find when scanning the
# source code. This list is not exhaustive, but it's still useful to identify
# when this script gets out of sync with the source. See load_objects().
#
expected_classes = [
    'ConsString', 'FixedArray', 'HeapNumber', 'JSArray', 'JSFunction',
319
    'JSObject', 'JSRegExp', 'JSPrimitiveWrapper', 'Map', 'Oddball', 'Script',
320 321
    'SeqOneByteString', 'SharedFunctionInfo', 'ScopeInfo', 'JSPromise',
    'DescriptorArray'
322 323 324 325 326 327 328
];


#
# The following structures store high-level representations of the structures
# for which we're going to emit descriptive constants.
#
329
types = {};       # set of all type names
330
typeclasses = {};       # maps type names to corresponding class names
331 332
klasses = {};     # known classes, including parents
fields = [];      # field declarations
333 334 335 336 337 338

header = '''
/*
 * This file is generated by %s.  Do not edit directly.
 */

339
#include "src/init/v8.h"
340
#include "src/codegen/register.h"
341 342
#include "src/execution/frames.h"
#include "src/execution/frames-inl.h" /* for architecture-specific frame constants */
343 344
#include "src/objects/contexts.h"
#include "src/objects/objects.h"
345
#include "src/objects/data-handler.h"
346
#include "src/objects/js-promise.h"
347
#include "src/objects/js-regexp-string-iterator.h"
348
#include "src/objects/megadom-handler.h"
349

350 351
namespace v8 {
namespace internal {
352 353 354 355 356

extern "C" {

/* stack frame constants */
#define FRAME_CONST(value, klass)       \
357
    V8_EXPORT int v8dbg_frametype_##klass = StackFrame::value;
358 359 360 361 362

STACK_FRAME_TYPE_LIST(FRAME_CONST)

#undef FRAME_CONST

363
''' % sys.argv[0]
364 365 366

footer = '''
}
367 368 369

}
}
370 371
'''

372 373 374 375
#
# Get the base class
#
def get_base_class(klass):
376 377
  if (klass == 'Object'):
    return klass;
378

379 380
  if (not (klass in klasses)):
    return None;
381

382
  k = klasses[klass];
383

384
  return get_base_class(k['parent']);
385

386
#
387
# Loads class hierarchy and type information from "objects.h" etc.
388 389
#
def load_objects():
390 391 392 393 394 395
  #
  # Construct a dictionary for the classes we're sure should be present.
  #
  checktypes = {};
  for klass in expected_classes:
    checktypes[klass] = True;
396

397

398 399 400
  for filename in sys.argv[2:]:
    if not filename.endswith("-inl.h"):
      load_objects_from_file(filename, checktypes)
401

402 403 404
  if (len(checktypes) > 0):
    for klass in checktypes:
      print('error: expected class \"%s\" not found' % klass);
405

406
    sys.exit(1);
407 408 409


def load_objects_from_file(objfilename, checktypes):
410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443
  objfile = io.open(objfilename, 'r', encoding='utf-8');
  in_insttype = False;
  in_torque_insttype = False
  in_torque_fulldef = False

  typestr = '';
  torque_typestr = ''
  torque_fulldefstr = ''
  uncommented_file = ''

  #
  # Iterate the header file line-by-line to collect type and class
  # information. For types, we accumulate a string representing the entire
  # InstanceType enum definition and parse it later because it's easier to
  # do so without the embedded newlines.
  #
  for line in objfile:
    if (line.startswith('enum InstanceType : uint16_t {')):
      in_insttype = True;
      continue;

    if (line.startswith('#define TORQUE_ASSIGNED_INSTANCE_TYPE_LIST')):
      in_torque_insttype = True
      continue

    if (line.startswith('#define TORQUE_INSTANCE_CHECKERS_SINGLE_FULLY_DEFINED')):
      in_torque_fulldef = True
      continue

    if (in_insttype and line.startswith('};')):
      in_insttype = False;
      continue;

    if (in_torque_insttype and (not line or line.isspace())):
444 445
      in_torque_insttype = False
      continue
446 447

    if (in_torque_fulldef and (not line or line.isspace())):
448 449
      in_torque_fulldef = False
      continue
450

451 452
    pre = line.strip()
    line = re.sub('// .*', '', line.strip());
453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500

    if (in_insttype):
      typestr += line;
      continue;

    if (in_torque_insttype):
      torque_typestr += line
      continue

    if (in_torque_fulldef):
      torque_fulldefstr += line
      continue

    uncommented_file += '\n' + line

  for match in re.finditer(r'\nclass(?:\s+V8_EXPORT(?:_PRIVATE)?)?'
         r'\s+(\w[^:;]*)'
         r'(?:: public (\w[^{]*))?\s*{\s*',
         uncommented_file):
    klass = match.group(1).strip();
    pklass = match.group(2);
    if (pklass):
      # Check for generated Torque class.
      gen_match = re.match(
          r'TorqueGenerated\w+\s*<\s*\w+,\s*(\w+)\s*>',
          pklass)
      if (gen_match):
        pklass = gen_match.group(1)
      # Strip potential template arguments from parent
      # class.
      match = re.match(r'(\w+)(<.*>)?', pklass.strip());
      pklass = match.group(1).strip();
    klasses[klass] = { 'parent': pklass };

  #
  # Process the instance type declaration.
  #
  entries = typestr.split(',');
  for entry in entries:
    types[re.sub('\s*=.*', '', entry).lstrip()] = True;
  entries = torque_typestr.split('\\')
  for entry in entries:
    name = re.sub(r' *V\(|\).*', '', entry)
    types[name] = True
  entries = torque_fulldefstr.split('\\')
  for entry in entries:
    entry = entry.strip()
    if not entry:
501
      continue
502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581
    start = entry.find('(');
    end = entry.find(')', start);
    rest = entry[start + 1: end];
    args = re.split('\s*,\s*', rest);
    typename = args[0]
    typeconst = args[1]
    types[typeconst] = True
    typeclasses[typeconst] = typename
  #
  # Infer class names for each type based on a systematic transformation.
  # For example, "JS_FUNCTION_TYPE" becomes "JSFunction".  We find the
  # class for each type rather than the other way around because there are
  # fewer cases where one type maps to more than one class than the other
  # way around.
  #
  for type in types:
    usetype = type

    #
    # Remove the "_TYPE" suffix and then convert to camel case,
    # except that a "JS" prefix remains uppercase (as in
    # "JS_FUNCTION_TYPE" => "JSFunction").
    #
    if (not usetype.endswith('_TYPE')):
      continue;

    usetype = usetype[0:len(usetype) - len('_TYPE')];
    parts = usetype.split('_');
    cctype = '';

    if (parts[0] == 'JS'):
      cctype = 'JS';
      start = 1;
    else:
      cctype = '';
      start = 0;

    for ii in range(start, len(parts)):
      part = parts[ii];
      cctype += part[0].upper() + part[1:].lower();

    #
    # Mapping string types is more complicated.  Both types and
    # class names for Strings specify a representation (e.g., Seq,
    # Cons, External, or Sliced) and an encoding (TwoByte/OneByte),
    # In the simplest case, both of these are explicit in both
    # names, as in:
    #
    #       EXTERNAL_ONE_BYTE_STRING_TYPE => ExternalOneByteString
    #
    # However, either the representation or encoding can be omitted
    # from the type name, in which case "Seq" and "TwoByte" are
    # assumed, as in:
    #
    #       STRING_TYPE => SeqTwoByteString
    #
    # Additionally, sometimes the type name has more information
    # than the class, as in:
    #
    #       CONS_ONE_BYTE_STRING_TYPE => ConsString
    #
    # To figure this out dynamically, we first check for a
    # representation and encoding and add them if they're not
    # present.  If that doesn't yield a valid class name, then we
    # strip out the representation.
    #
    if (cctype.endswith('String')):
      if (cctype.find('Cons') == -1 and
          cctype.find('External') == -1 and
          cctype.find('Sliced') == -1):
        if (cctype.find('OneByte') != -1):
          cctype = re.sub('OneByteString$',
              'SeqOneByteString', cctype);
        else:
          cctype = re.sub('String$',
              'SeqString', cctype);

      if (cctype.find('OneByte') == -1):
        cctype = re.sub('String$', 'TwoByteString',
            cctype);
582

583 584 585 586 587 588 589 590 591 592 593
      if (not (cctype in klasses)):
        cctype = re.sub('OneByte', '', cctype);
        cctype = re.sub('TwoByte', '', cctype);

    #
    # Despite all that, some types have no corresponding class.
    #
    if (cctype in klasses):
      typeclasses[type] = cctype;
      if (cctype in checktypes):
        del checktypes[cctype];
594 595 596 597 598 599

#
# For a given macro call, pick apart the arguments and return an object
# describing the corresponding output constant.  See load_fields().
#
def parse_field(call):
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631
  # Replace newlines with spaces.
  for ii in range(0, len(call)):
    if (call[ii] == '\n'):
      call[ii] == ' ';

  idx = call.find('(');
  kind = call[0:idx];
  rest = call[idx + 1: len(call) - 1];
  args = re.split('\s*,\s*', rest);

  consts = [];

  klass = args[0];
  field = args[1];
  dtype = None
  offset = None
  if kind.startswith('WEAK_ACCESSORS'):
    dtype = 'weak'
    offset = args[2];
  elif not (kind.startswith('SMI_ACCESSORS') or kind.startswith('ACCESSORS_TO_SMI')):
    dtype = args[2].replace('<', '_').replace('>', '_')
    offset = args[3];
  else:
    offset = args[2];
    dtype = 'SMI'


  assert(offset is not None and dtype is not None);
  return ({
      'name': 'class_%s__%s__%s' % (klass, field, dtype),
      'value': '%s::%s' % (klass, offset)
  });
632 633

#
634
# Load field offset information from objects-inl.h etc.
635 636
#
def load_fields():
637 638 639
  for filename in sys.argv[2:]:
    if filename.endswith("-inl.h"):
      load_fields_from_file(filename)
640

641 642
  for body in extras_accessors:
    fields.append(parse_field('ACCESSORS(%s)' % body));
643 644 645


def load_fields_from_file(filename):
646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683
  inlfile = io.open(filename, 'r', encoding='utf-8');

  #
  # Each class's fields and the corresponding offsets are described in the
  # source by calls to macros like "ACCESSORS" (and friends).  All we do
  # here is extract these macro invocations, taking into account that they
  # may span multiple lines and may contain nested parentheses.  We also
  # call parse_field() to pick apart the invocation.
  #
  prefixes = [ 'ACCESSORS', 'ACCESSORS2', 'ACCESSORS_GCSAFE',
         'SMI_ACCESSORS', 'ACCESSORS_TO_SMI',
         'RELEASE_ACQUIRE_ACCESSORS', 'WEAK_ACCESSORS' ];
  prefixes += ([ prefix + "_CHECKED" for prefix in prefixes ] +
         [ prefix + "_CHECKED2" for prefix in prefixes ])
  current = '';
  opens = 0;

  for line in inlfile:
    if (opens > 0):
      # Continuation line
      for ii in range(0, len(line)):
        if (line[ii] == '('):
          opens += 1;
        elif (line[ii] == ')'):
          opens -= 1;

        if (opens == 0):
          break;

      current += line[0:ii + 1];
      continue;

    for prefix in prefixes:
      if (not line.startswith(prefix + '(')):
        continue;

      if (len(current) > 0):
        fields.append(parse_field(current));
684 685
        current = '';

686 687 688 689 690
      for ii in range(len(prefix), len(line)):
        if (line[ii] == '('):
          opens += 1;
        elif (line[ii] == ')'):
          opens -= 1;
691

692 693
        if (opens == 0):
          break;
694

695
      current += line[0:ii + 1];
696

697 698 699
  if (len(current) > 0):
    fields.append(parse_field(current));
    current = '';
700 701 702 703 704

#
# Emit a block of constants.
#
def emit_set(out, consts):
705
  lines = set()  # To remove duplicates.
706

707 708 709 710 711 712 713
  # Fix up overzealous parses.  This could be done inside the
  # parsers but as there are several, it's easiest to do it here.
  ws = re.compile('\s+')
  for const in consts:
    name = ws.sub('', const['name'])
    value = ws.sub('', str(const['value']))  # Can be a number.
    lines.add('V8_EXPORT int v8dbg_%s = %s;\n' % (name, value))
714

715 716 717
  for line in lines:
    out.write(line);
  out.write('\n');
718 719 720 721 722

#
# Emit the whole output file.
#
def emit_config():
723
  out = open(sys.argv[1], 'w');
724

725
  out.write(header);
726

727 728
  out.write('/* miscellaneous constants */\n');
  emit_set(out, consts_misc);
729

730 731 732 733 734 735 736 737
  out.write('/* class type information */\n');
  consts = [];
  for typename in sorted(typeclasses):
    klass = typeclasses[typename];
    consts.append({
        'name': 'type_%s__%s' % (klass, typename),
        'value': typename
    });
738

739
  emit_set(out, consts);
740

741 742 743 744 745 746 747 748 749
  out.write('/* class hierarchy information */\n');
  consts = [];
  for klassname in sorted(klasses):
    pklass = klasses[klassname]['parent'];
    bklass = get_base_class(klassname);
    if (bklass != 'Object'):
      continue;
    if (pklass == None):
      continue;
750

751 752 753 754
    consts.append({
        'name': 'parent_%s__%s' % (klassname, pklass),
        'value': 0
    });
755

756
  emit_set(out, consts);
757

758 759
  out.write('/* field information */\n');
  emit_set(out, fields);
760

761
  out.write(footer);
762 763

if (len(sys.argv) < 4):
764 765
  print('usage: %s output.cc objects.h objects-inl.h' % sys.argv[0]);
  sys.exit(2);
766 767 768 769

load_objects();
load_fields();
emit_config();