Upgrade to 3.29

Update V8 to 3.29.88.17 and update makefiles to support building on
all the relevant platforms.

Bug: 17370214

Change-Id: Ia3407c157fd8d72a93e23d8318ccaf6ecf77fa4e
diff --git a/tools/gen-postmortem-metadata.py b/tools/gen-postmortem-metadata.py
index b9b1625..04a1ea8 100644
--- a/tools/gen-postmortem-metadata.py
+++ b/tools/gen-postmortem-metadata.py
@@ -61,13 +61,14 @@
 
     { 'name': 'StringEncodingMask',     'value': 'kStringEncodingMask' },
     { 'name': 'TwoByteStringTag',       'value': 'kTwoByteStringTag' },
-    { 'name': 'AsciiStringTag',         'value': 'kAsciiStringTag' },
+    { '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': 'FailureTag',             'value': 'kFailureTag' },
     { 'name': 'FailureTagMask',         'value': 'kFailureTagMask' },
@@ -76,21 +77,59 @@
     { 'name': 'SmiTag',                 'value': 'kSmiTag' },
     { 'name': 'SmiTagMask',             'value': 'kSmiTagMask' },
     { 'name': 'SmiValueShift',          'value': 'kSmiTagSize' },
+    { 'name': 'SmiShiftSize',           'value': 'kSmiShiftSize' },
     { 'name': 'PointerSizeLog2',        'value': 'kPointerSizeLog2' },
 
-    { 'name': 'prop_idx_content',
-        'value': 'DescriptorArray::kContentArrayIndex' },
+    { 'name': 'OddballFalse',           'value': 'Oddball::kFalse' },
+    { 'name': 'OddballTrue',            'value': 'Oddball::kTrue' },
+    { 'name': 'OddballTheHole',         'value': 'Oddball::kTheHole' },
+    { 'name': 'OddballNull',            'value': 'Oddball::kNull' },
+    { 'name': 'OddballArgumentMarker',  'value': 'Oddball::kArgumentMarker' },
+    { 'name': 'OddballUndefined',       'value': 'Oddball::kUndefined' },
+    { 'name': 'OddballUninitialized',   'value': 'Oddball::kUninitialized' },
+    { 'name': 'OddballOther',           'value': 'Oddball::kOther' },
+    { 'name': 'OddballException',       'value': 'Oddball::kException' },
+
     { 'name': 'prop_idx_first',
         'value': 'DescriptorArray::kFirstIndex' },
     { 'name': 'prop_type_field',
         'value': 'FIELD' },
     { 'name': 'prop_type_first_phantom',
-        'value': 'MAP_TRANSITION' },
+        'value': 'TRANSITION' },
     { 'name': 'prop_type_mask',
         'value': 'PropertyDetails::TypeField::kMask' },
+    { 'name': 'prop_index_mask',
+        'value': 'PropertyDetails::FieldIndexField::kMask' },
+    { 'name': 'prop_index_shift',
+        'value': 'PropertyDetails::FieldIndexField::kShift' },
+
+    { 'name': 'prop_desc_key',
+        'value': 'DescriptorArray::kDescriptorKey' },
+    { 'name': 'prop_desc_details',
+        'value': 'DescriptorArray::kDescriptorDetails' },
+    { 'name': 'prop_desc_value',
+        'value': 'DescriptorArray::kDescriptorValue' },
+    { 'name': 'prop_desc_size',
+        'value': 'DescriptorArray::kDescriptorSize' },
+
+    { 'name': 'elements_fast_holey_elements',
+        'value': 'FAST_HOLEY_ELEMENTS' },
+    { 'name': 'elements_fast_elements',
+        'value': 'FAST_ELEMENTS' },
+    { 'name': 'elements_dictionary_elements',
+        'value': 'DICTIONARY_ELEMENTS' },
+
+    { 'name': 'bit_field2_elements_kind_mask',
+       'value': 'Map::kElementsKindMask' },
+    { 'name': 'bit_field2_elements_kind_shift',
+       'value': 'Map::kElementsKindShift' },
+    { 'name': 'bit_field3_dictionary_map_shift',
+        'value': 'Map::DictionaryMap::kShift' },
 
     { 'name': 'off_fp_context',
         'value': 'StandardFrameConstants::kContextOffset' },
+    { 'name': 'off_fp_constant_pool',
+        'value': 'StandardFrameConstants::kConstantPoolOffset' },
     { 'name': 'off_fp_marker',
         'value': 'StandardFrameConstants::kMarkerOffset' },
     { 'name': 'off_fp_function',
@@ -107,15 +146,26 @@
     'JSObject, elements, Object, kElementsOffset',
     'FixedArray, data, uintptr_t, kHeaderSize',
     'Map, instance_attributes, int, kInstanceAttributesOffset',
-    'Map, instance_descriptors, int, kInstanceDescriptorsOrBitField3Offset',
     'Map, inobject_properties, int, kInObjectPropertiesOffset',
     'Map, instance_size, int, kInstanceSizeOffset',
+    'Map, bit_field, char, kBitFieldOffset',
+    'Map, bit_field2, char, kBitField2Offset',
+    'Map, bit_field3, SMI, kBitField3Offset',
+    'Map, prototype, Object, kPrototypeOffset',
+    'NameDictionaryShape, prefix_size, int, kPrefixSize',
+    'NameDictionaryShape, entry_size, int, kEntrySize',
+    'SeededNumberDictionaryShape, prefix_size, int, kPrefixSize',
+    'UnseededNumberDictionaryShape, prefix_size, int, kPrefixSize',
+    'NumberDictionaryShape, entry_size, int, kEntrySize',
+    'Oddball, kind_offset, int, kKindOffset',
     'HeapNumber, value, double, kValueOffset',
     'ConsString, first, String, kFirstOffset',
     'ConsString, second, String, kSecondOffset',
     'ExternalString, resource, Object, kResourceOffset',
-    'SeqAsciiString, chars, char, kHeaderSize',
+    'SeqOneByteString, chars, char, kHeaderSize',
+    'SeqTwoByteString, chars, char, kHeaderSize',
     'SharedFunctionInfo, code, Code, kCodeOffset',
+    'SlicedString, parent, String, kParentOffset',
     'Code, instruction_start, uintptr_t, kHeaderSize',
     'Code, instruction_size, int, kInstructionSizeOffset',
 ];
@@ -128,7 +178,7 @@
 expected_classes = [
     'ConsString', 'FixedArray', 'HeapNumber', 'JSArray', 'JSFunction',
     'JSObject', 'JSRegExp', 'JSValue', 'Map', 'Oddball', 'Script',
-    'SeqAsciiString', 'SharedFunctionInfo'
+    'SeqOneByteString', 'SharedFunctionInfo'
 ];
 
 
@@ -265,11 +315,11 @@
                 #
                 # 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 or Ascii),
+                # Cons, External, or Sliced) and an encoding (TwoByte/OneByte),
                 # In the simplest case, both of these are explicit in both
                 # names, as in:
                 #
-                #       EXTERNAL_ASCII_STRING_TYPE => ExternalAsciiString
+                #       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
@@ -280,7 +330,7 @@
                 # Additionally, sometimes the type name has more information
                 # than the class, as in:
                 #
-                #       CONS_ASCII_STRING_TYPE => ConsString
+                #       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
@@ -291,19 +341,19 @@
                         if (cctype.find('Cons') == -1 and
                             cctype.find('External') == -1 and
                             cctype.find('Sliced') == -1):
-                                if (cctype.find('Ascii') != -1):
-                                        cctype = re.sub('AsciiString$',
-                                            'SeqAsciiString', cctype);
+                                if (cctype.find('OneByte') != -1):
+                                        cctype = re.sub('OneByteString$',
+                                            'SeqOneByteString', cctype);
                                 else:
                                         cctype = re.sub('String$',
                                             'SeqString', cctype);
 
-                        if (cctype.find('Ascii') == -1):
+                        if (cctype.find('OneByte') == -1):
                                 cctype = re.sub('String$', 'TwoByteString',
                                     cctype);
 
                         if (not (cctype in klasses)):
-                                cctype = re.sub('Ascii', '', cctype);
+                                cctype = re.sub('OneByte', '', cctype);
                                 cctype = re.sub('TwoByte', '', cctype);
 
                 #
@@ -349,7 +399,7 @@
                     'value': '%s::%s' % (klass, offset)
                 });
 
-        assert(kind == 'SMI_ACCESSORS');
+        assert(kind == 'SMI_ACCESSORS' or kind == 'ACCESSORS_TO_SMI');
         klass = args[0];
         field = args[1];
         offset = args[2];
@@ -373,7 +423,8 @@
         # may span multiple lines and may contain nested parentheses.  We also
         # call parse_field() to pick apart the invocation.
         #
-        prefixes = [ 'ACCESSORS', 'ACCESSORS_GCSAFE', 'SMI_ACCESSORS' ];
+        prefixes = [ 'ACCESSORS', 'ACCESSORS_GCSAFE',
+                     'SMI_ACCESSORS', 'ACCESSORS_TO_SMI' ];
         current = '';
         opens = 0;
 
@@ -422,9 +473,13 @@
 # Emit a block of constants.
 #
 def emit_set(out, consts):
-        for ii in range(0, len(consts)):
-                out.write('int v8dbg_%s = %s;\n' %
-                    (consts[ii]['name'], consts[ii]['value']));
+        # 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.
+                out.write('int v8dbg_%s = %s;\n' % (name, value))
         out.write('\n');
 
 #