| #!/usr/bin/env python3 |
| |
| # |
| # 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. |
| # |
| |
| # for py2/py3 compatibility |
| from __future__ import print_function |
| |
| import io |
| import re |
| import sys |
| |
| # |
| # Miscellaneous constants such as tags and masks used for object identification, |
| # enumeration values used as indexes in internal tables, etc.. |
| # |
| consts_misc = [ |
| { |
| 'name': 'FirstNonstringType', |
| 'value': 'FIRST_NONSTRING_TYPE' |
| }, |
| { |
| 'name': 'APIObjectType', |
| 'value': 'JS_API_OBJECT_TYPE' |
| }, |
| { |
| 'name': 'SpecialAPIObjectType', |
| 'value': 'JS_SPECIAL_API_OBJECT_TYPE' |
| }, |
| { |
| 'name': 'FirstContextType', |
| 'value': 'FIRST_CONTEXT_TYPE' |
| }, |
| { |
| 'name': 'LastContextType', |
| 'value': 'LAST_CONTEXT_TYPE' |
| }, |
| { |
| 'name': 'FirstJSFunctionType', |
| 'value': 'FIRST_JS_FUNCTION_TYPE' |
| }, |
| { |
| 'name': 'LastJSFunctionType', |
| 'value': 'LAST_JS_FUNCTION_TYPE' |
| }, |
| { |
| 'name': 'IsNotStringMask', |
| 'value': 'kIsNotStringMask' |
| }, |
| { |
| 'name': 'StringTag', |
| 'value': 'kStringTag' |
| }, |
| { |
| 'name': 'StringEncodingMask', |
| 'value': 'kStringEncodingMask' |
| }, |
| { |
| 'name': 'TwoByteStringTag', |
| 'value': 'kTwoByteStringTag' |
| }, |
| { |
| 'name': 'OneByteStringTag', |
| 'value': 'kOneByteStringTag' |
| }, |
| { |
| 'name': 'StringRepresentationMask', |
| 'value': 'kStringRepresentationMask' |
| }, |
| { |
| 'name': 'SeqStringTag', |
| 'value': 'kSeqStringTag' |
| }, |
| { |
| 'name': 'ConsStringTag', |
| 'value': 'kConsStringTag' |
| }, |
| { |
| 'name': 'ExternalStringTag', |
| 'value': 'kExternalStringTag' |
| }, |
| { |
| 'name': 'SlicedStringTag', |
| 'value': 'kSlicedStringTag' |
| }, |
| { |
| 'name': 'ThinStringTag', |
| 'value': 'kThinStringTag' |
| }, |
| { |
| 'name': 'HeapObjectTag', |
| 'value': 'kHeapObjectTag' |
| }, |
| { |
| 'name': 'HeapObjectTagMask', |
| 'value': 'kHeapObjectTagMask' |
| }, |
| { |
| 'name': 'SmiTag', |
| 'value': 'kSmiTag' |
| }, |
| { |
| 'name': 'SmiTagMask', |
| 'value': 'kSmiTagMask' |
| }, |
| { |
| 'name': 'SmiValueShift', |
| 'value': 'kSmiTagSize' |
| }, |
| { |
| 'name': 'SmiShiftSize', |
| 'value': 'kSmiShiftSize' |
| }, |
| { |
| 'name': 'SystemPointerSize', |
| 'value': 'kSystemPointerSize' |
| }, |
| { |
| 'name': 'SystemPointerSizeLog2', |
| 'value': 'kSystemPointerSizeLog2' |
| }, |
| { |
| 'name': 'TaggedSize', |
| 'value': 'kTaggedSize' |
| }, |
| { |
| 'name': 'TaggedSizeLog2', |
| 'value': 'kTaggedSizeLog2' |
| }, |
| { |
| 'name': 'CodeKindFieldMask', |
| 'value': 'Code::KindField::kMask' |
| }, |
| { |
| 'name': 'CodeKindFieldShift', |
| 'value': 'Code::KindField::kShift' |
| }, |
| { |
| 'name': 'DeoptimizationDataInlinedFunctionCountIndex', |
| 'value': 'DeoptimizationData::kInlinedFunctionCountIndex' |
| }, |
| { |
| 'name': 'DeoptimizationDataLiteralArrayIndex', |
| 'value': 'DeoptimizationData::kLiteralArrayIndex' |
| }, |
| { |
| 'name': 'DeoptimizationDataOptimizationIdIndex', |
| 'value': 'DeoptimizationData::kOptimizationIdIndex' |
| }, |
| { |
| 'name': 'DeoptimizationDataSharedFunctionInfoWrapperIndex', |
| 'value': 'DeoptimizationData::kSharedFunctionInfoWrapperIndex' |
| }, |
| { |
| 'name': 'DeoptimizationDataInliningPositionsIndex', |
| 'value': 'DeoptimizationData::kInliningPositionsIndex' |
| }, |
| { |
| '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)' |
| }, |
| { |
| 'name': 'OddballFalse', |
| 'value': 'Oddball::kFalse' |
| }, |
| { |
| 'name': 'OddballTrue', |
| 'value': 'Oddball::kTrue' |
| }, |
| { |
| 'name': 'OddballNull', |
| 'value': 'Oddball::kNull' |
| }, |
| { |
| 'name': 'OddballUndefined', |
| 'value': 'Oddball::kUndefined' |
| }, |
| { |
| 'name': 'ContextRegister', |
| 'value': 'kContextRegister.code()' |
| }, |
| { |
| 'name': 'ReturnRegister0', |
| 'value': 'kReturnRegister0.code()' |
| }, |
| { |
| 'name': 'JSFunctionRegister', |
| 'value': 'kJSFunctionRegister.code()' |
| }, |
| { |
| 'name': 'InterpreterBytecodeOffsetRegister', |
| 'value': 'kInterpreterBytecodeOffsetRegister.code()' |
| }, |
| { |
| 'name': 'InterpreterBytecodeArrayRegister', |
| 'value': 'kInterpreterBytecodeArrayRegister.code()' |
| }, |
| { |
| 'name': 'RuntimeCallFunctionRegister', |
| 'value': 'kRuntimeCallFunctionRegister.code()' |
| }, |
| { |
| 'name': 'prop_kind_Data', |
| 'value': 'static_cast<int>(PropertyKind::kData)' |
| }, |
| { |
| 'name': 'prop_kind_Accessor', |
| 'value': 'static_cast<int>(PropertyKind::kAccessor)' |
| }, |
| { |
| 'name': 'prop_kind_mask', |
| 'value': 'PropertyDetails::KindField::kMask' |
| }, |
| { |
| 'name': 'prop_location_Descriptor', |
| 'value': 'static_cast<int>(PropertyLocation::kDescriptor)' |
| }, |
| { |
| 'name': 'prop_location_Field', |
| 'value': 'static_cast<int>(PropertyLocation::kField)' |
| }, |
| { |
| 'name': 'prop_location_mask', |
| 'value': 'PropertyDetails::LocationField::kMask' |
| }, |
| { |
| 'name': 'prop_location_shift', |
| 'value': 'PropertyDetails::LocationField::kShift' |
| }, |
| { |
| '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', |
| 'value': 'PropertyDetails::AttributesField::kMask' |
| }, |
| { |
| 'name': 'prop_attributes_shift', |
| 'value': 'PropertyDetails::AttributesField::kShift' |
| }, |
| { |
| 'name': 'prop_index_mask', |
| 'value': 'PropertyDetails::FieldIndexField::kMask' |
| }, |
| { |
| 'name': 'prop_index_shift', |
| 'value': 'PropertyDetails::FieldIndexField::kShift' |
| }, |
| { |
| 'name': 'prop_representation_mask', |
| 'value': 'PropertyDetails::RepresentationField::kMask' |
| }, |
| { |
| 'name': 'prop_representation_shift', |
| 'value': 'PropertyDetails::RepresentationField::kShift' |
| }, |
| { |
| 'name': 'prop_representation_smi', |
| 'value': 'Representation::Kind::kSmi' |
| }, |
| { |
| 'name': 'prop_representation_double', |
| 'value': 'Representation::Kind::kDouble' |
| }, |
| { |
| 'name': 'prop_representation_heapobject', |
| 'value': 'Representation::Kind::kHeapObject' |
| }, |
| { |
| 'name': 'prop_representation_tagged', |
| 'value': 'Representation::Kind::kTagged' |
| }, |
| { |
| 'name': 'prop_desc_key', |
| 'value': 'DescriptorArray::kEntryKeyIndex' |
| }, |
| { |
| 'name': 'prop_desc_details', |
| 'value': 'DescriptorArray::kEntryDetailsIndex' |
| }, |
| { |
| 'name': 'prop_desc_value', |
| 'value': 'DescriptorArray::kEntryValueIndex' |
| }, |
| { |
| 'name': 'prop_desc_size', |
| 'value': 'DescriptorArray::kEntrySize' |
| }, |
| { |
| 'name': 'elements_fast_holey_elements', |
| 'value': 'HOLEY_ELEMENTS' |
| }, |
| { |
| 'name': 'elements_fast_elements', |
| 'value': 'PACKED_ELEMENTS' |
| }, |
| { |
| 'name': 'elements_dictionary_elements', |
| 'value': 'DICTIONARY_ELEMENTS' |
| }, |
| { |
| 'name': 'bit_field2_elements_kind_mask', |
| 'value': 'Map::Bits2::ElementsKindBits::kMask' |
| }, |
| { |
| 'name': 'bit_field2_elements_kind_shift', |
| 'value': 'Map::Bits2::ElementsKindBits::kShift' |
| }, |
| { |
| 'name': 'bit_field3_is_dictionary_map_shift', |
| 'value': 'Map::Bits3::IsDictionaryMapBit::kShift' |
| }, |
| { |
| 'name': 'bit_field3_number_of_own_descriptors_mask', |
| 'value': 'Map::Bits3::NumberOfOwnDescriptorsBits::kMask' |
| }, |
| { |
| 'name': 'bit_field3_number_of_own_descriptors_shift', |
| 'value': 'Map::Bits3::NumberOfOwnDescriptorsBits::kShift' |
| }, |
| { |
| 'name': 'class_Map__instance_descriptors_offset', |
| 'value': 'Map::kInstanceDescriptorsOffset' |
| }, |
| { |
| 'name': 'off_fp_context_or_frame_type', |
| 'value': 'CommonFrameConstants::kContextOrFrameTypeOffset' |
| }, |
| { |
| 'name': 'off_fp_context', |
| 'value': 'StandardFrameConstants::kContextOffset' |
| }, |
| { |
| 'name': 'off_fp_constant_pool', |
| 'value': 'StandardFrameConstants::kConstantPoolOffset' |
| }, |
| { |
| 'name': 'off_fp_function', |
| 'value': 'StandardFrameConstants::kFunctionOffset' |
| }, |
| { |
| 'name': 'off_fp_args', |
| 'value': 'StandardFrameConstants::kFixedFrameSizeAboveFp' |
| }, |
| { |
| 'name': 'off_fp_bytecode_array', |
| 'value': 'InterpreterFrameConstants::kBytecodeArrayFromFp' |
| }, |
| { |
| 'name': 'off_fp_bytecode_offset', |
| 'value': 'InterpreterFrameConstants::kBytecodeOffsetFromFp' |
| }, |
| { |
| 'name': 'scopeinfo_idx_nparams', |
| 'value': 'ScopeInfo::kParameterCount' |
| }, |
| { |
| 'name': 'scopeinfo_idx_ncontextlocals', |
| 'value': 'ScopeInfo::kContextLocalCount' |
| }, |
| { |
| 'name': 'scopeinfo_idx_first_vars', |
| 'value': 'ScopeInfo::kVariablePartIndex' |
| }, |
| { |
| 'name': 'jsarray_buffer_was_detached_mask', |
| 'value': 'JSArrayBuffer::WasDetachedBit::kMask' |
| }, |
| { |
| 'name': 'jsarray_buffer_was_detached_shift', |
| 'value': 'JSArrayBuffer::WasDetachedBit::kShift' |
| }, |
| { |
| 'name': 'context_idx_scope_info', |
| 'value': 'Context::SCOPE_INFO_INDEX' |
| }, |
| { |
| 'name': 'context_idx_prev', |
| 'value': 'Context::PREVIOUS_INDEX' |
| }, |
| { |
| 'name': 'context_min_slots', |
| 'value': 'Context::MIN_CONTEXT_SLOTS' |
| }, |
| { |
| 'name': 'native_context_embedder_data_offset', |
| 'value': 'Internals::kNativeContextEmbedderDataOffset' |
| }, |
| { |
| 'name': 'namedictionaryshape_prefix_size', |
| 'value': 'NameDictionaryShape::kPrefixSize' |
| }, |
| { |
| 'name': 'namedictionaryshape_entry_size', |
| 'value': 'NameDictionaryShape::kEntrySize' |
| }, |
| { |
| 'name': 'globaldictionaryshape_entry_size', |
| 'value': 'GlobalDictionaryShape::kEntrySize' |
| }, |
| { |
| 'name': 'namedictionary_prefix_start_index', |
| 'value': 'NameDictionary::kPrefixStartIndex' |
| }, |
| { |
| 'name': 'numberdictionaryshape_prefix_size', |
| 'value': 'NumberDictionaryShape::kPrefixSize' |
| }, |
| { |
| 'name': 'numberdictionaryshape_entry_size', |
| 'value': 'NumberDictionaryShape::kEntrySize' |
| }, |
| { |
| 'name': 'simplenumberdictionaryshape_prefix_size', |
| 'value': 'SimpleNumberDictionaryShape::kPrefixSize' |
| }, |
| { |
| 'name': 'simplenumberdictionaryshape_entry_size', |
| 'value': 'SimpleNumberDictionaryShape::kEntrySize' |
| }, |
| { |
| 'name': 'type_JSError__JS_ERROR_TYPE', |
| 'value': 'JS_ERROR_TYPE' |
| }, |
| ] |
| |
| # |
| # The following useful fields are missing accessors, so we define fake ones. |
| # 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. |
| # |
| extras_accessors = [ |
| 'JSFunction, code, Tagged<Code>, kCodeOffset', |
| 'JSFunction, context, Context, kContextOffset', |
| 'JSFunction, shared, SharedFunctionInfo, kSharedFunctionInfoOffset', |
| 'HeapObject, map, Map, kMapOffset', |
| 'JSObject, elements, Object, kElementsOffset', |
| 'JSObject, internal_fields, uintptr_t, kHeaderSize', |
| 'FixedArray, data, uintptr_t, kHeaderSize', |
| 'BytecodeArray, data, uintptr_t, kHeaderSize', |
| 'JSArrayBuffer, backing_store, uintptr_t, kBackingStoreOffset', |
| 'JSArrayBuffer, byte_length, size_t, kRawByteLengthOffset', |
| 'JSArrayBufferView, byte_length, size_t, kRawByteLengthOffset', |
| 'JSArrayBufferView, byte_offset, size_t, kRawByteOffsetOffset', |
| 'JSDate, value, Object, kValueOffset', |
| 'JSRegExp, source, Object, kSourceOffset', |
| 'JSTypedArray, external_pointer, uintptr_t, kExternalPointerOffset', |
| 'JSTypedArray, length, Object, kRawLengthOffset', |
| 'Map, instance_size_in_words, char, kInstanceSizeInWordsOffset', |
| 'Map, inobject_properties_start_or_constructor_function_index, char, kInobjectPropertiesStartOrConstructorFunctionIndexOffset', |
| 'Map, instance_type, uint16_t, kInstanceTypeOffset', |
| 'Map, bit_field, char, kBitFieldOffset', |
| 'Map, bit_field2, char, kBitField2Offset', |
| 'Map, bit_field3, int, kBitField3Offset', |
| 'Map, prototype, Object, kPrototypeOffset', |
| 'Oddball, kind, int, offsetof(Oddball, kind_)', |
| 'HeapNumber, value, double, offsetof(HeapNumber, value_)', |
| 'ExternalString, resource, Object, offsetof(ExternalString, resource_)', |
| 'SeqOneByteString, chars, char, OFFSET_OF_DATA_START(SeqOneByteString)', |
| 'SeqTwoByteString, chars, char, OFFSET_OF_DATA_START(SeqTwoByteString)', |
| 'UncompiledData, inferred_name, String, kInferredNameOffset', |
| 'UncompiledData, start_position, int32_t, kStartPositionOffset', |
| 'UncompiledData, end_position, int32_t, kEndPositionOffset', |
| 'Script, source, Object, kSourceOffset', |
| 'Script, name, Object, kNameOffset', |
| 'Script, line_ends, Object, kLineEndsOffset', |
| 'SharedFunctionInfo, raw_function_token_offset, int16_t, kFunctionTokenOffsetOffset', |
| 'SharedFunctionInfo, internal_formal_parameter_count, uint16_t, kFormalParameterCountOffset', |
| 'SharedFunctionInfo, flags, int, kFlagsOffset', |
| 'SharedFunctionInfo, length, uint16_t, kLengthOffset', |
| 'SlicedString, parent, String, offsetof(SlicedString, parent_)', |
| 'Code, flags, uint32_t, kFlagsOffset', |
| 'Code, instruction_start, Address, kInstructionStartOffset', |
| 'Code, instruction_stream, Tagged<InstructionStream>, kInstructionStreamOffset', |
| 'Code, instruction_size, int, kInstructionSizeOffset', |
| 'InstructionStream, instruction_start, uintptr_t, kHeaderSize', |
| 'String, length, int32_t, offsetof(String, length_)', |
| 'DescriptorArray, header_size, uintptr_t, kHeaderSize', |
| 'ConsString, first, String, offsetof(ConsString, first_)', |
| 'ConsString, second, String, offsetof(ConsString, second_)', |
| 'SlicedString, offset, SMI, offsetof(SlicedString, offset_)', |
| 'ThinString, actual, String, offsetof(ThinString, actual_)', |
| 'Symbol, name, Object, offsetof(Symbol, description_)', |
| 'FixedArrayBase, length, SMI, kLengthOffset', |
| ] |
| |
| # |
| # 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', |
| 'JSObject', 'JSRegExp', 'JSPrimitiveWrapper', 'Map', 'Oddball', 'Script', |
| 'SeqOneByteString', 'SharedFunctionInfo', 'ScopeInfo', 'JSPromise', |
| 'DescriptorArray' |
| ]; |
| |
| |
| # |
| # The following structures store high-level representations of the structures |
| # for which we're going to emit descriptive constants. |
| # |
| types = {} # set of all type names |
| typeclasses = {} # maps type names to corresponding class names |
| klasses = {} # known classes, including parents |
| fields = [] # field declarations |
| offsetof_fields = [] # field declarations using offsetof |
| |
| header = ''' |
| /* |
| * This file is generated by %s. Do not edit directly. |
| */ |
| |
| #include "src/init/v8.h" |
| #include "src/codegen/register.h" |
| #include "src/execution/frames.h" |
| #include "src/execution/frames-inl.h" /* for architecture-specific frame constants */ |
| #include "src/objects/contexts.h" |
| #include "src/objects/objects.h" |
| #include "src/objects/data-handler.h" |
| #include "src/objects/js-promise.h" |
| #include "src/objects/js-regexp-string-iterator.h" |
| #include "src/objects/megadom-handler.h" |
| |
| namespace v8 { |
| namespace internal { |
| |
| extern "C" { |
| |
| /* stack frame constants */ |
| #define FRAME_CONST(value, klass) \ |
| V8_EXPORT int v8dbg_frametype_##klass = StackFrame::value; |
| |
| STACK_FRAME_TYPE_LIST(FRAME_CONST) |
| |
| #undef FRAME_CONST |
| |
| ''' % sys.argv[0] |
| |
| footer = ''' |
| } |
| |
| } |
| } |
| ''' |
| |
| # |
| # Get the base class |
| # |
| def get_base_class(klass): |
| if (klass == 'Object'): |
| return klass; |
| |
| if (not (klass in klasses)): |
| return None; |
| |
| k = klasses[klass]; |
| |
| return get_base_class(k['parent']); |
| |
| # |
| # Loads class hierarchy and type information from "objects.h" etc. |
| # |
| def load_objects(): |
| # |
| # Construct a dictionary for the classes we're sure should be present. |
| # |
| checktypes = {}; |
| for klass in expected_classes: |
| checktypes[klass] = True; |
| |
| |
| for filename in sys.argv[2:]: |
| if not filename.endswith("-inl.h"): |
| load_objects_from_file(filename, checktypes) |
| |
| if (len(checktypes) > 0): |
| for klass in checktypes: |
| print('error: expected class \"%s\" not found' % klass); |
| |
| sys.exit(1); |
| |
| |
| def load_objects_from_file(objfilename, checktypes): |
| 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())): |
| in_torque_insttype = False |
| continue |
| |
| if (in_torque_fulldef and (not line or line.isspace())): |
| in_torque_fulldef = False |
| continue |
| |
| pre = line.strip() |
| line = re.sub('// .*', '', line.strip()); |
| |
| 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'\n(?:V8_OBJECT\s+)?class(?:\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(r'\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: |
| continue |
| start = entry.find('('); |
| end = entry.find(')', start); |
| rest = entry[start + 1: end]; |
| args = re.split(r'\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, 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. |
| # If that doesn't yield a valid class name, we strip out the |
| # representation. |
| # |
| if (cctype.endswith('String')): |
| 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]; |
| |
| # |
| # 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): |
| # 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.findall(r'[^\s,][^(),]*(?:\([^()]*\))?(?=\s*(?:,|$))', rest) |
| |
| 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' |
| |
| if offset.startswith("offsetof(") or offset.startswith( |
| "OFFSET_OF_DATA_START("): |
| offsetof_fields.append((klass, field, offset)) |
| value = 'OffsetsForDebug::%s_%s' % (klass, field) |
| else: |
| value = '%s::%s' % (klass, offset) |
| |
| assert(offset is not None and dtype is not None); |
| return ({'name': 'class_%s__%s__%s' % (klass, field, dtype), 'value': value}) |
| |
| # |
| # Load field offset information from objects-inl.h etc. |
| # |
| def load_fields(): |
| for filename in sys.argv[2:]: |
| if filename.endswith("-inl.h"): |
| load_fields_from_file(filename) |
| |
| for body in extras_accessors: |
| fields.append(parse_field('ACCESSORS(%s)' % body)); |
| |
| |
| def load_fields_from_file(filename): |
| 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)); |
| current = ''; |
| |
| for ii in range(len(prefix), len(line)): |
| if (line[ii] == '('): |
| opens += 1; |
| elif (line[ii] == ')'): |
| opens -= 1; |
| |
| if (opens == 0): |
| break; |
| |
| current += line[0:ii + 1]; |
| |
| if (len(current) > 0): |
| fields.append(parse_field(current)); |
| current = ''; |
| |
| # |
| # Emit a block of constants. |
| # |
| def emit_constants(out, consts): |
| lines = [] |
| |
| # 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(r'\s+') |
| for const in consts: |
| name = ws.sub('', const['name']) |
| value = ws.sub('', str(const['value'])) # Can be a number. |
| lines.append('V8_EXPORT int v8dbg_%s = %s;' % (name, value)) |
| |
| # Generate without duplicates and with preserved order. |
| out.write('\n'.join(dict.fromkeys(lines))) |
| out.write('\n'); |
| |
| # |
| # Emit the whole output file. |
| # |
| def emit_config(): |
| out = open(sys.argv[1], 'w'); |
| |
| out.write(header); |
| |
| out.write("struct OffsetsForDebug {\n") |
| for (klass, field, offset) in offsetof_fields: |
| out.write(" static const int %s_%s = %s;\n" % (klass, field, offset)) |
| out.write("};\n") |
| |
| out.write('/* miscellaneous constants */\n'); |
| emit_constants(out, consts_misc); |
| |
| 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 |
| }); |
| |
| emit_constants(out, consts); |
| |
| out.write('/* class hierarchy information */\n'); |
| consts = []; |
| for klassname in sorted(klasses): |
| pklass = klasses[klassname]['parent']; |
| if (klassname == pklass): |
| continue |
| bklass = get_base_class(klassname); |
| if (bklass != 'Object'): |
| continue; |
| if (pklass is None): |
| continue; |
| |
| consts.append({ |
| 'name': 'parent_%s__%s' % (klassname, pklass), |
| 'value': 0 |
| }); |
| |
| emit_constants(out, consts); |
| |
| out.write('/* field information */\n'); |
| emit_constants(out, fields); |
| |
| out.write(footer); |
| |
| if (len(sys.argv) < 4): |
| print('usage: %s output.cc objects.h objects-inl.h' % sys.argv[0]); |
| sys.exit(2); |
| |
| load_objects(); |
| load_fields(); |
| emit_config(); |
