32 #if defined(V8_TARGET_ARCH_MIPS)
48 #define __ ACCESS_MASM(masm)
51 static void GenerateGlobalInstanceTypeCheck(MacroAssembler* masm,
53 Label* global_object) {
64 static void GenerateStringDictionaryReceiverCheck(MacroAssembler* masm,
79 __ JumpIfSmi(receiver, miss);
82 __ GetObjectType(receiver, scratch0, scratch1);
88 GenerateGlobalInstanceTypeCheck(masm, scratch1, miss);
94 __ Branch(miss,
ne, scratch1, Operand(zero_reg));
98 __ LoadRoot(scratch0, Heap::kHashTableMapRootIndex);
99 __ Branch(miss,
ne, scratch1, Operand(scratch0));
118 static void GenerateDictionaryLoad(MacroAssembler* masm,
145 const int kDetailsOffset = kElementsStartOffset + 2 *
kPointerSize;
149 Operand(PropertyDetails::TypeField::kMask <<
kSmiTagSize));
150 __ Branch(miss,
ne, at, Operand(zero_reg));
171 static void GenerateDictionaryStore(MacroAssembler* masm,
198 const int kDetailsOffset = kElementsStartOffset + 2 *
kPointerSize;
199 const int kTypeAndReadOnlyMask =
200 (PropertyDetails::TypeField::kMask |
203 __ And(at, scratch1, Operand(kTypeAndReadOnlyMask));
204 __ Branch(miss,
ne, at, Operand(zero_reg));
207 const int kValueOffset = kElementsStartOffset +
kPointerSize;
212 __ mov(scratch1, value);
227 StubCompiler::GenerateLoadArrayLength(masm, a0, a3, &miss);
242 StubCompiler::GenerateLoadStringLength(masm, a0, a1, a3, &miss,
259 StubCompiler::GenerateLoadFunctionPrototype(masm, a0, a1, a3, &miss);
267 static void GenerateKeyedLoadReceiverCheck(MacroAssembler* masm,
274 __ JumpIfSmi(receiver, slow);
280 __ Branch(slow,
ne, at, Operand(zero_reg));
293 static void GenerateFastArrayLoad(MacroAssembler* masm,
300 Label* not_fast_array,
301 Label* out_of_range) {
325 if (not_fast_array !=
NULL) {
328 __ LoadRoot(at, Heap::kFixedArrayMapRootIndex);
329 __ Branch(not_fast_array,
ne, scratch1, Operand(at));
331 __ AssertFastElements(elements);
336 __ Branch(out_of_range,
hs, key, Operand(scratch1));
339 __ Addu(scratch1, elements,
344 __ addu(at, at, scratch1);
347 __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
350 __ Branch(out_of_range,
eq, scratch2, Operand(at));
351 __ mov(result, scratch2);
357 static void GenerateKeyStringCheck(MacroAssembler* masm,
365 __ GetObjectType(key, map, hash);
371 __ Branch(index_string,
eq, at, Operand(zero_reg));
378 __ Branch(not_symbol,
eq, at, Operand(zero_reg));
383 Object* CallIC_Miss(Arguments args);
395 Label number, non_number, non_string, boolean, probe, miss;
403 Isolate::Current()->stub_cache()->GenerateProbe(
404 masm, flags, a1, a2, a3, t0, t1, t2);
412 __ JumpIfSmi(a1, &number, t1);
413 __ GetObjectType(a1, a3, a3);
416 StubCompiler::GenerateLoadGlobalFunctionPrototype(
421 __ bind(&non_number);
423 StubCompiler::GenerateLoadGlobalFunctionPrototype(
428 __ bind(&non_string);
429 __ LoadRoot(t0, Heap::kTrueValueRootIndex);
430 __ Branch(&
boolean,
eq, a1, Operand(t0));
431 __ LoadRoot(t1, Heap::kFalseValueRootIndex);
432 __ Branch(&miss,
ne, a1, Operand(t1));
434 StubCompiler::GenerateLoadGlobalFunctionPrototype(
439 Isolate::Current()->stub_cache()->GenerateProbe(
440 masm, flags, a1, a2, a3, t0, t1, t2);
446 static void GenerateFunctionTailCall(MacroAssembler* masm,
453 __ JumpIfSmi(a1, miss);
456 __ GetObjectType(a1, scratch, scratch);
460 ParameterCount actual(argc);
476 GenerateStringDictionaryReceiverCheck(masm, a1, a0, a3, t0, &miss);
480 GenerateDictionaryLoad(masm, &miss, a0, a2, a1, a3, t0);
482 GenerateFunctionTailCall(masm, argc, &miss, t0);
497 Isolate*
isolate = masm->isolate();
499 if (
id == IC::kCallIC_Miss) {
500 __ IncrementCounter(isolate->counters()->call_miss(), 1, a3, t0);
502 __ IncrementCounter(isolate->counters()->keyed_call_miss(), 1, a3, t0);
515 __ PrepareCEntryArgs(2);
516 __ PrepareCEntryFunction(ExternalReference(IC_Utility(
id), isolate));
527 if (
id == IC::kCallIC_Miss) {
528 Label invoke, global;
530 __ JumpIfSmi(a2, &invoke);
531 __ GetObjectType(a2, a3, a3);
545 ParameterCount actual(argc);
546 __ InvokeFunction(a1,
578 Label do_call, slow_call, slow_load, slow_reload_receiver;
579 Label check_number_dictionary, check_string, lookup_monomorphic_cache;
580 Label index_smi, index_string;
583 __ JumpIfNotSmi(a2, &check_string);
588 GenerateKeyedLoadReceiverCheck(
591 GenerateFastArrayLoad(
592 masm, a1, a2, t0, a3, a0, a1, &check_number_dictionary, &slow_load);
593 Counters* counters = masm->isolate()->counters();
594 __ IncrementCounter(counters->keyed_call_generic_smi_fast(), 1, a0, a3);
601 GenerateFunctionTailCall(masm, argc, &slow_call, a0);
603 __ bind(&check_number_dictionary);
608 __ LoadRoot(at, Heap::kHashTableMapRootIndex);
609 __ Branch(&slow_load,
ne, a3, Operand(at));
612 __ LoadFromNumberDictionary(&slow_load, t0, a2, a1, a0, a3, t1);
613 __ IncrementCounter(counters->keyed_call_generic_smi_dict(), 1, a0, a3);
619 __ IncrementCounter(counters->keyed_call_generic_slow_load(), 1, a0, a3);
624 __ CallRuntime(Runtime::kKeyedGetProperty, 2);
630 __ bind(&check_string);
631 GenerateKeyStringCheck(masm, a2, a0, a3, &index_string, &slow_call);
637 GenerateKeyedLoadReceiverCheck(
642 __ LoadRoot(at, Heap::kHashTableMapRootIndex);
643 __ Branch(&lookup_monomorphic_cache,
ne, a3, Operand(at));
645 GenerateDictionaryLoad(masm, &slow_load, a0, a2, a1, a3, t0);
646 __ IncrementCounter(counters->keyed_call_generic_lookup_dict(), 1, a0, a3);
649 __ bind(&lookup_monomorphic_cache);
650 __ IncrementCounter(counters->keyed_call_generic_lookup_cache(), 1, a0, a3);
664 __ IncrementCounter(counters->keyed_call_generic_slow(), 1, a0, a3);
667 __ bind(&index_string);
668 __ IndexFromHash(a3, a2);
682 __ JumpIfSmi(a2, &miss);
683 __ IsObjectJSStringType(a2, a0, &miss);
692 Object* LoadIC_Miss(Arguments args);
704 Isolate::Current()->stub_cache()->GenerateProbe(
705 masm, flags, a0, a2, a3, t0, t1, t2);
721 GenerateStringDictionaryReceiverCheck(masm, a0, a1, a3, t0, &miss);
724 GenerateDictionaryLoad(masm, &miss, a1, a2, v0, a3, t0);
740 Isolate* isolate = masm->isolate();
742 __ IncrementCounter(isolate->counters()->keyed_load_miss(), 1, a3, t0);
748 ExternalReference ref = ExternalReference(IC_Utility(kLoadIC_Miss), isolate);
749 __ TailCallExternalReference(ref, 2, 1);
753 static MemOperand GenerateMappedArgumentsLookup(MacroAssembler* masm,
759 Label* unmapped_case,
764 __ JumpIfSmi(
object, slow_case);
766 __ GetObjectType(
object, scratch1, scratch2);
770 __ And(scratch1, key, Operand(0x80000001));
771 __ Branch(slow_case,
ne, scratch1, Operand(zero_reg));
775 __ CheckMap(scratch1,
777 Heap::kNonStrictArgumentsElementsMapRootIndex,
790 __ li(scratch3, Operand(kPointerSize >> 1));
791 __ Mul(scratch3, key, scratch3);
792 __ Addu(scratch3, scratch3, Operand(kOffset));
794 __ Addu(scratch2, scratch1, scratch3);
796 __ LoadRoot(scratch3, Heap::kTheHoleValueRootIndex);
797 __ Branch(unmapped_case,
eq, scratch2, Operand(scratch3));
803 __ li(scratch3, Operand(kPointerSize >> 1));
804 __ Mul(scratch3, scratch2, scratch3);
806 __ Addu(scratch2, scratch1, scratch3);
811 static MemOperand GenerateUnmappedArgumentsLookup(MacroAssembler* masm,
813 Register parameter_map,
821 Register backing_store = parameter_map;
823 __ CheckMap(backing_store,
825 Heap::kFixedArrayMapRootIndex,
830 __ li(scratch, Operand(kPointerSize >> 1));
831 __ Mul(scratch, key, scratch);
835 __ Addu(scratch, backing_store, scratch);
848 GenerateMappedArgumentsLookup(masm, a1, a0, a2, a3, t0, ¬in, &slow);
850 __ lw(v0, mapped_location);
854 GenerateUnmappedArgumentsLookup(masm, a0, a2, a3, &slow);
855 __ lw(a2, unmapped_location);
856 __ LoadRoot(a3, Heap::kTheHoleValueRootIndex);
857 __ Branch(&slow,
eq, a2, Operand(a3));
875 GenerateMappedArgumentsLookup(masm, a2, a1, a3, t0, t1, ¬in, &slow);
876 __ sw(a0, mapped_location);
879 __ RecordWrite(a3, mapped_location.rm(), t5,
887 GenerateUnmappedArgumentsLookup(masm, a1, a3, t0, &slow);
888 __ sw(a0, unmapped_location);
890 ASSERT_EQ(unmapped_location.offset(), 0);
891 __ RecordWrite(a3, unmapped_location.rm(), t5,
910 GenerateMappedArgumentsLookup(masm, a1, a2, a3, t0, t1, ¬in, &slow);
911 __ lw(a1, mapped_location);
912 GenerateFunctionTailCall(masm, argc, &slow, a3);
916 GenerateUnmappedArgumentsLookup(masm, a2, a3, t0, &slow);
917 __ lw(a1, unmapped_location);
918 __ LoadRoot(a3, Heap::kTheHoleValueRootIndex);
919 __ Branch(&slow,
eq, a1, Operand(a3));
920 GenerateFunctionTailCall(masm, argc, &slow, a3);
926 Object* KeyedLoadIC_Miss(Arguments args);
935 Isolate* isolate = masm->isolate();
937 __ IncrementCounter(isolate->counters()->keyed_load_miss(), 1, a3, t0);
942 ExternalReference ref = force_generic
943 ? ExternalReference(IC_Utility(kKeyedLoadIC_MissForceGeneric), isolate)
944 : ExternalReference(IC_Utility(kKeyedLoadIC_Miss), isolate);
946 __ TailCallExternalReference(ref, 2, 1);
959 __ TailCallRuntime(Runtime::kKeyedGetProperty, 2, 1);
969 Label slow, check_string, index_smi, index_string, property_array_property;
970 Label probe_dictionary, check_number_dictionary;
973 Register receiver = a1;
975 Isolate* isolate = masm->isolate();
978 __ JumpIfNotSmi(key, &check_string);
983 GenerateKeyedLoadReceiverCheck(
987 __ CheckFastElements(a2, a3, &check_number_dictionary);
989 GenerateFastArrayLoad(
990 masm, receiver, key, t0, a3, a2, v0,
NULL, &slow);
992 __ IncrementCounter(isolate->counters()->keyed_load_generic_smi(), 1, a2, a3);
995 __ bind(&check_number_dictionary);
1003 __ LoadRoot(at, Heap::kHashTableMapRootIndex);
1004 __ Branch(&slow,
ne, a3, Operand(at));
1006 __ LoadFromNumberDictionary(&slow, t0, a0, v0, a2, a3, t1);
1011 __ IncrementCounter(isolate->counters()->keyed_load_generic_slow(),
1017 __ bind(&check_string);
1018 GenerateKeyStringCheck(masm, key, a2, a3, &index_string, &slow);
1020 GenerateKeyedLoadReceiverCheck(
1028 __ LoadRoot(at, Heap::kHashTableMapRootIndex);
1029 __ Branch(&probe_dictionary,
eq, t0, Operand(at));
1037 __ xor_(a3, a3, at);
1039 __ And(a3, a3, Operand(mask));
1043 Label load_in_object_property;
1045 Label hit_on_nth_entry[kEntriesPerBucket];
1046 ExternalReference cache_keys =
1047 ExternalReference::keyed_lookup_cache_keys(isolate);
1048 __ li(t0, Operand(cache_keys));
1050 __ addu(t0, t0, at);
1052 for (
int i = 0; i < kEntriesPerBucket - 1; i++) {
1053 Label try_next_entry;
1055 __ Branch(&try_next_entry,
ne, a2, Operand(t1));
1057 __ Branch(&hit_on_nth_entry[i],
eq, a0, Operand(t1));
1058 __ bind(&try_next_entry);
1061 __ lw(t1,
MemOperand(t0, kPointerSize * (kEntriesPerBucket - 1) * 2));
1062 __ Branch(&slow,
ne, a2, Operand(t1));
1063 __ lw(t1,
MemOperand(t0, kPointerSize * ((kEntriesPerBucket - 1) * 2 + 1)));
1064 __ Branch(&slow,
ne, a0, Operand(t1));
1071 ExternalReference cache_field_offsets =
1072 ExternalReference::keyed_lookup_cache_field_offsets(isolate);
1075 for (
int i = kEntriesPerBucket - 1; i >= 0; i--) {
1076 __ bind(&hit_on_nth_entry[i]);
1077 __ li(t0, Operand(cache_field_offsets));
1079 __ addu(at, t0, at);
1082 __ Subu(t1, t1, t2);
1083 __ Branch(&property_array_property,
ge, t1, Operand(zero_reg));
1085 __ Branch(&load_in_object_property);
1090 __ bind(&load_in_object_property);
1092 __ addu(t2, t2, t1);
1093 __ Subu(a1, a1, Operand(kHeapObjectTag));
1095 __ addu(at, a1, at);
1097 __ IncrementCounter(isolate->counters()->keyed_load_generic_lookup_cache(),
1104 __ bind(&property_array_property);
1108 __ Addu(t0, t0, a1);
1110 __ IncrementCounter(isolate->counters()->keyed_load_generic_lookup_cache(),
1119 __ bind(&probe_dictionary);
1125 GenerateGlobalInstanceTypeCheck(masm, a2, &slow);
1127 GenerateDictionaryLoad(masm, &slow, a3, a0, v0, a2, t0);
1128 __ IncrementCounter(isolate->counters()->keyed_load_generic_symbol(),
1134 __ bind(&index_string);
1135 __ IndexFromHash(a3, key);
1137 __ Branch(&index_smi);
1149 Register receiver = a1;
1150 Register index = a0;
1151 Register scratch = a3;
1152 Register result = v0;
1154 StringCharAtGenerator char_at_generator(receiver,
1162 char_at_generator.GenerateFast(masm);
1165 StubRuntimeCallHelper call_helper;
1166 char_at_generator.GenerateSlow(masm, call_helper);
1183 __ Push(a2, a1, a0);
1188 __ TailCallRuntime(Runtime::kSetProperty, 5, 1);
1200 Label slow, array, extra, check_if_double_array;
1201 Label fast_object_with_map_check, fast_object_without_map_check;
1202 Label fast_double_with_map_check, fast_double_without_map_check;
1203 Label transition_smi_elements, finish_object_store, non_double_value;
1204 Label transition_double_elements;
1207 Register value = a0;
1209 Register receiver = a2;
1210 Register receiver_map = a3;
1211 Register elements_map = t2;
1212 Register elements = t3;
1216 __ JumpIfNotSmi(key, &slow);
1218 __ JumpIfSmi(receiver, &slow);
1225 __ Branch(&slow,
ne, t0, Operand(zero_reg));
1236 __ Branch(&fast_object_with_map_check,
lo, key, Operand(t0));
1252 __ Branch(&slow,
ne, key, Operand(t0));
1256 __ Branch(&slow,
hs, key, Operand(t0));
1259 &check_if_double_array,
ne, elements_map, Heap::kFixedArrayMapRootIndex);
1265 __ Branch(&fast_object_without_map_check);
1267 __ bind(&check_if_double_array);
1268 __ Branch(&slow,
ne, elements_map, Heap::kFixedDoubleArrayMapRootIndex);
1273 __ jmp(&fast_double_without_map_check);
1283 __ Branch(&extra,
hs, key, Operand(t0));
1286 __ bind(&fast_object_with_map_check);
1287 Register scratch_value = t0;
1290 __ Branch(&fast_double_with_map_check,
1293 Heap::kFixedArrayMapRootIndex);
1294 __ bind(&fast_object_without_map_check);
1296 Label non_smi_value;
1297 __ JumpIfNotSmi(value, &non_smi_value);
1301 __ Addu(address, address, scratch_value);
1306 __ bind(&non_smi_value);
1308 __ CheckFastObjectElements(receiver_map, scratch_value,
1309 &transition_smi_elements);
1311 __ bind(&finish_object_store);
1314 __ Addu(address, address, scratch_value);
1318 __ RecordWrite(elements,
1327 __ bind(&fast_double_with_map_check);
1330 __ Branch(&slow,
ne, elements_map, Heap::kFixedDoubleArrayMapRootIndex);
1331 __ bind(&fast_double_without_map_check);
1332 __ StoreNumberToDoubleElements(value,
1340 &transition_double_elements);
1344 __ bind(&transition_smi_elements);
1347 __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
1348 __ Branch(&non_double_value,
ne, t0, Operand(at));
1358 ASSERT(receiver_map.is(a3));
1361 __ jmp(&fast_double_without_map_check);
1363 __ bind(&non_double_value);
1370 ASSERT(receiver_map.is(a3));
1373 __ jmp(&finish_object_store);
1375 __ bind(&transition_double_elements);
1384 ASSERT(receiver_map.is(a3));
1387 __ jmp(&finish_object_store);
1400 __ JumpIfSmi(a1, &slow);
1404 __ Branch(&slow,
ne, t0, Operand(zero_reg));
1418 __ TailCallExternalReference(ExternalReference(
1419 IC_Utility(kKeyedLoadPropertyWithInterceptor), masm->isolate()), 2, 1);
1435 __ Push(a2, a1, a0);
1437 ExternalReference ref = force_generic
1438 ? ExternalReference(IC_Utility(kKeyedStoreIC_MissForceGeneric),
1440 : ExternalReference(IC_Utility(kKeyedStoreIC_Miss), masm->isolate());
1441 __ TailCallExternalReference(ref, 3, 1);
1455 __ Push(a2, a1, a0);
1459 ExternalReference ref =
1460 ExternalReference(IC_Utility(kKeyedStoreIC_Slow), masm->isolate());
1462 __ TailCallExternalReference(ref, 3, 1);
1473 if (!FLAG_trace_elements_transitions) {
1482 __ TailCallRuntime(Runtime::kTransitionElementsSmiToDouble, 1, 1);
1487 MacroAssembler* masm) {
1494 if (!FLAG_trace_elements_transitions) {
1503 __ TailCallRuntime(Runtime::kTransitionElementsDoubleToObject, 1, 1);
1519 Isolate::Current()->stub_cache()->GenerateProbe(
1520 masm, flags, a1, a2, a3, t0, t1, t2);
1535 __ Push(a1, a2, a0);
1537 ExternalReference ref = ExternalReference(IC_Utility(kStoreIC_Miss),
1539 __ TailCallExternalReference(ref, 3, 1);
1558 Register receiver = a1;
1559 Register value = a0;
1560 Register scratch = a3;
1563 __ JumpIfSmi(receiver, &miss);
1566 __ GetObjectType(receiver, scratch, scratch);
1573 __ GetObjectType(scratch, scratch, scratch);
1580 __ LoadRoot(at, Heap::kHashTableMapRootIndex);
1581 __ Branch(&miss,
eq, scratch, Operand(at));
1584 __ JumpIfNotSmi(value, &miss);
1587 __ Push(receiver, value);
1589 ExternalReference ref = ExternalReference(IC_Utility(kStoreIC_ArrayLength),
1591 __ TailCallExternalReference(ref, 2, 1);
1608 GenerateStringDictionaryReceiverCheck(masm, a1, a3, t0, t1, &miss);
1610 GenerateDictionaryStore(masm, &miss, a3, a2, a0, t0, t1);
1611 Counters* counters = masm->isolate()->counters();
1612 __ IncrementCounter(counters->store_normal_hit(), 1, t0, t1);
1616 __ IncrementCounter(counters->store_normal_miss(), 1, t0, t1);
1630 __ Push(a1, a2, a0);
1637 __ TailCallRuntime(Runtime::kSetProperty, 5, 1);
1646 case Token::EQ_STRICT:
1666 Handle<Code> rewritten;
1667 State previous_state = GetState();
1668 State state = TargetState(previous_state,
false, x, y);
1671 rewritten = stub.GetCode();
1673 ICCompareStub stub(op_, state);
1675 stub.set_known_map(Handle<Map>(Handle<JSObject>::cast(x)->map()));
1677 rewritten = stub.GetCode();
1682 if (FLAG_trace_ic) {
1683 PrintF(
"[CompareIC (%s->%s)#%s]\n",
1698 Address andi_instruction_address =
1720 if (FLAG_trace_ic) {
1721 PrintF(
"[ patching ic at %p, andi=%p, delta=%d\n",
1722 address, andi_instruction_address, delta);
1729 Instr branch_instr =
1739 CodePatcher patcher(patch_address, 2);
1748 patcher.masm()->andi(at, reg, 0);
1752 patcher.ChangeBranchCondition(
ne);
1755 patcher.ChangeBranchCondition(
eq);
1762 #endif // V8_TARGET_ARCH_MIPS
static bool IsBranch(Instr instr)
static void GenerateTransitionElementsDoubleToObject(MacroAssembler *masm)
static const int kBitFieldOffset
static void GenerateRuntimeGetProperty(MacroAssembler *masm)
const intptr_t kSmiTagMask
const intptr_t kSmiSignMask
static uint32_t GetRt(Instr instr)
static const int kElementsStartIndex
static void GenerateNormal(MacroAssembler *masm, int argc)
static const int kMapHashShift
void PrintF(const char *format,...)
static void GenerateGeneric(MacroAssembler *masm, StrictModeFlag strict_mode)
static const char * Name(Value tok)
static Smi * FromInt(int value)
static void GenerateMiss(MacroAssembler *masm, int argc, IC::UtilityId id, Code::ExtraICState extra_state)
static uint32_t GetImmediate16(Instr instr)
value format" "after each garbage collection") DEFINE_bool(print_cumulative_gc_stat, false, "print cumulative GC statistics in name=value format on exit") DEFINE_bool(trace_gc_verbose, false, "print more details following each garbage collection") DEFINE_bool(trace_fragmentation, false, "report fragmentation for old pointer and data pages") DEFINE_bool(collect_maps, true, "garbage collect maps from which no objects can be reached") DEFINE_bool(flush_code, true, "flush code that we expect not to use again before full gc") DEFINE_bool(incremental_marking, true, "use incremental marking") DEFINE_bool(incremental_marking_steps, true, "do incremental marking steps") DEFINE_bool(trace_incremental_marking, false, "trace progress of the incremental marking") DEFINE_bool(use_idle_notification, true, "Use idle notification to reduce memory footprint.") DEFINE_bool(send_idle_notification, false, "Send idle notifcation between stress runs.") DEFINE_bool(use_ic, true, "use inline caching") DEFINE_bool(native_code_counters, false, "generate extra code for manipulating stats counters") DEFINE_bool(always_compact, false, "Perform compaction on every full GC") DEFINE_bool(lazy_sweeping, true, "Use lazy sweeping for old pointer and data spaces") DEFINE_bool(never_compact, false, "Never perform compaction on full GC-testing only") DEFINE_bool(compact_code_space, true, "Compact code space on full non-incremental collections") DEFINE_bool(cleanup_code_caches_at_gc, true, "Flush inline caches prior to mark compact collection and" "flush code caches in maps during mark compact cycle.") DEFINE_int(random_seed, 0, "Default seed for initializing random generator" "(0, the default, means to use system random).") DEFINE_bool(use_verbose_printer, true, "allows verbose printing") DEFINE_bool(allow_natives_syntax, false, "allow natives syntax") DEFINE_bool(trace_sim, false, "Trace simulator execution") DEFINE_bool(check_icache, false, "Check icache flushes in ARM and MIPS simulator") DEFINE_int(stop_sim_at, 0, "Simulator stop after x number of instructions") DEFINE_int(sim_stack_alignment, 8, "Stack alingment in bytes in simulator(4 or 8, 8 is default)") DEFINE_bool(trace_exception, false, "print stack trace when throwing exceptions") DEFINE_bool(preallocate_message_memory, false, "preallocate some memory to build stack traces.") DEFINE_bool(randomize_hashes, true, "randomize hashes to avoid predictable hash collisions" "(with snapshots this option cannot override the baked-in seed)") DEFINE_int(hash_seed, 0, "Fixed seed to use to hash property keys(0 means random)" "(with snapshots this option cannot override the baked-in seed)") DEFINE_bool(preemption, false, "activate a 100ms timer that switches between V8 threads") DEFINE_bool(regexp_optimization, true, "generate optimized regexp code") DEFINE_bool(testing_bool_flag, true, "testing_bool_flag") DEFINE_int(testing_int_flag, 13, "testing_int_flag") DEFINE_float(testing_float_flag, 2.5, "float-flag") DEFINE_string(testing_string_flag, "Hello, world!", "string-flag") DEFINE_int(testing_prng_seed, 42, "Seed used for threading test randomness") DEFINE_string(testing_serialization_file, "/tmp/serdes", "file in which to serialize heap") DEFINE_bool(help, false, "Print usage message, including flags, on console") DEFINE_bool(dump_counters, false, "Dump counters on exit") DEFINE_string(map_counters, "", "Map counters to a file") DEFINE_args(js_arguments, JSARGUMENTS_INIT, "Pass all remaining arguments to the script.Alias for\"--\".") DEFINE_bool(debug_compile_events, true,"Enable debugger compile events") DEFINE_bool(debug_script_collected_events, true,"Enable debugger script collected events") DEFINE_bool(gdbjit, false,"enable GDBJIT interface (disables compacting GC)") DEFINE_bool(gdbjit_full, false,"enable GDBJIT interface for all code objects") DEFINE_bool(gdbjit_dump, false,"dump elf objects with debug info to disk") DEFINE_string(gdbjit_dump_filter,"","dump only objects containing this substring") DEFINE_bool(force_marking_deque_overflows, false,"force overflows of marking deque by reducing it's size ""to 64 words") DEFINE_bool(stress_compaction, false,"stress the GC compactor to flush out bugs (implies ""--force_marking_deque_overflows)")#define FLAG DEFINE_bool(enable_slow_asserts, false,"enable asserts that are slow to execute") DEFINE_bool(trace_codegen, false,"print name of functions for which code is generated") DEFINE_bool(print_source, false,"pretty print source code") DEFINE_bool(print_builtin_source, false,"pretty print source code for builtins") DEFINE_bool(print_ast, false,"print source AST") DEFINE_bool(print_builtin_ast, false,"print source AST for builtins") DEFINE_string(stop_at,"","function name where to insert a breakpoint") DEFINE_bool(print_builtin_scopes, false,"print scopes for builtins") DEFINE_bool(print_scopes, false,"print scopes") DEFINE_bool(trace_contexts, false,"trace contexts operations") DEFINE_bool(gc_greedy, false,"perform GC prior to some allocations") DEFINE_bool(gc_verbose, false,"print stuff during garbage collection") DEFINE_bool(heap_stats, false,"report heap statistics before and after GC") DEFINE_bool(code_stats, false,"report code statistics after GC") DEFINE_bool(verify_heap, false,"verify heap pointers before and after GC") DEFINE_bool(print_handles, false,"report handles after GC") DEFINE_bool(print_global_handles, false,"report global handles after GC") DEFINE_bool(trace_ic, false,"trace inline cache state transitions") DEFINE_bool(print_interfaces, false,"print interfaces") DEFINE_bool(print_interface_details, false,"print interface inference details") DEFINE_int(print_interface_depth, 5,"depth for printing interfaces") DEFINE_bool(trace_normalization, false,"prints when objects are turned into dictionaries.") DEFINE_bool(trace_lazy, false,"trace lazy compilation") DEFINE_bool(collect_heap_spill_statistics, false,"report heap spill statistics along with heap_stats ""(requires heap_stats)") DEFINE_bool(trace_isolates, false,"trace isolate state changes") DEFINE_bool(log_state_changes, false,"Log state changes.") DEFINE_bool(regexp_possessive_quantifier, false,"enable possessive quantifier syntax for testing") DEFINE_bool(trace_regexp_bytecodes, false,"trace regexp bytecode execution") DEFINE_bool(trace_regexp_assembler, false,"trace regexp macro assembler calls.")#define FLAG DEFINE_bool(log, false,"Minimal logging (no API, code, GC, suspect, or handles samples).") DEFINE_bool(log_all, false,"Log all events to the log file.") DEFINE_bool(log_runtime, false,"Activate runtime system %Log call.") DEFINE_bool(log_api, false,"Log API events to the log file.") DEFINE_bool(log_code, false,"Log code events to the log file without profiling.") DEFINE_bool(log_gc, false,"Log heap samples on garbage collection for the hp2ps tool.") DEFINE_bool(log_handles, false,"Log global handle events.") DEFINE_bool(log_snapshot_positions, false,"log positions of (de)serialized objects in the snapshot.") DEFINE_bool(log_suspect, false,"Log suspect operations.") DEFINE_bool(prof, false,"Log statistical profiling information (implies --log-code).") DEFINE_bool(prof_auto, true,"Used with --prof, starts profiling automatically") DEFINE_bool(prof_lazy, false,"Used with --prof, only does sampling and logging"" when profiler is active (implies --noprof_auto).") DEFINE_bool(prof_browser_mode, true,"Used with --prof, turns on browser-compatible mode for profiling.") DEFINE_bool(log_regexp, false,"Log regular expression execution.") DEFINE_bool(sliding_state_window, false,"Update sliding state window counters.") DEFINE_string(logfile,"v8.log","Specify the name of the log file.") DEFINE_bool(ll_prof, false,"Enable low-level linux profiler.")#define FLAG DEFINE_bool(trace_elements_transitions, false,"trace elements transitions") DEFINE_bool(print_code_stubs, false,"print code stubs") DEFINE_bool(test_secondary_stub_cache, false,"test secondary stub cache by disabling the primary one") DEFINE_bool(test_primary_stub_cache, false,"test primary stub cache by disabling the secondary one") DEFINE_bool(print_code, false,"print generated code") DEFINE_bool(print_opt_code, false,"print optimized code") DEFINE_bool(print_unopt_code, false,"print unoptimized code before ""printing optimized code based on it") DEFINE_bool(print_code_verbose, false,"print more information for code") DEFINE_bool(print_builtin_code, false,"print generated code for builtins")#43"/Users/thlorenz/dev/dx/v8-perf/build/v8/src/flags.cc"2#define FLAG_MODE_DEFINE_DEFAULTS#1"/Users/thlorenz/dev/dx/v8-perf/build/v8/src/flag-definitions.h"1#define FLAG_FULL(ftype, ctype, nam, def, cmt)#define FLAG_READONLY(ftype, ctype, nam, def, cmt)#define DEFINE_implication(whenflag, thenflag)#define DEFINE_bool(nam, def, cmt)#define DEFINE_int(nam, def, cmt)#define DEFINE_float(nam, def, cmt)#define DEFINE_string(nam, def, cmt)#define DEFINE_args(nam, def, cmt)#define FLAG DEFINE_bool(use_strict, false,"enforce strict mode") DEFINE_bool(es5_readonly, false,"activate correct semantics for inheriting readonliness") DEFINE_bool(es52_globals, false,"activate new semantics for global var declarations") DEFINE_bool(harmony_typeof, false,"enable harmony semantics for typeof") DEFINE_bool(harmony_scoping, false,"enable harmony block scoping") DEFINE_bool(harmony_modules, false,"enable harmony modules (implies block scoping)") DEFINE_bool(harmony_proxies, false,"enable harmony proxies") DEFINE_bool(harmony_collections, false,"enable harmony collections (sets, maps, and weak maps)") DEFINE_bool(harmony, false,"enable all harmony features (except typeof)") DEFINE_implication(harmony, harmony_scoping) DEFINE_implication(harmony, harmony_modules) DEFINE_implication(harmony, harmony_proxies) DEFINE_implication(harmony, harmony_collections) DEFINE_implication(harmony_modules, harmony_scoping) DEFINE_bool(packed_arrays, false,"optimizes arrays that have no holes") DEFINE_bool(smi_only_arrays, true,"tracks arrays with only smi values") DEFINE_bool(clever_optimizations, true,"Optimize object size, Array shift, DOM strings and string +") DEFINE_bool(unbox_double_arrays, true,"automatically unbox arrays of doubles") DEFINE_bool(string_slices, true,"use string slices") DEFINE_bool(crankshaft, true,"use crankshaft") DEFINE_string(hydrogen_filter,"","optimization filter") DEFINE_bool(use_range, true,"use hydrogen range analysis") DEFINE_bool(eliminate_dead_phis, true,"eliminate dead phis") DEFINE_bool(use_gvn, true,"use hydrogen global value numbering") DEFINE_bool(use_canonicalizing, true,"use hydrogen instruction canonicalizing") DEFINE_bool(use_inlining, true,"use function inlining") DEFINE_int(max_inlined_source_size, 600,"maximum source size in bytes considered for a single inlining") DEFINE_int(max_inlined_nodes, 196,"maximum number of AST nodes considered for a single inlining") DEFINE_int(max_inlined_nodes_cumulative, 196,"maximum cumulative number of AST nodes considered for inlining") DEFINE_bool(loop_invariant_code_motion, true,"loop invariant code motion") DEFINE_bool(collect_megamorphic_maps_from_stub_cache, true,"crankshaft harvests type feedback from stub cache") DEFINE_bool(hydrogen_stats, false,"print statistics for hydrogen") DEFINE_bool(trace_hydrogen, false,"trace generated hydrogen to file") DEFINE_string(trace_phase,"Z","trace generated IR for specified phases") DEFINE_bool(trace_inlining, false,"trace inlining decisions") DEFINE_bool(trace_alloc, false,"trace register allocator") DEFINE_bool(trace_all_uses, false,"trace all use positions") DEFINE_bool(trace_range, false,"trace range analysis") DEFINE_bool(trace_gvn, false,"trace global value numbering") DEFINE_bool(trace_representation, false,"trace representation types") DEFINE_bool(stress_pointer_maps, false,"pointer map for every instruction") DEFINE_bool(stress_environments, false,"environment for every instruction") DEFINE_int(deopt_every_n_times, 0,"deoptimize every n times a deopt point is passed") DEFINE_bool(trap_on_deopt, false,"put a break point before deoptimizing") DEFINE_bool(deoptimize_uncommon_cases, true,"deoptimize uncommon cases") DEFINE_bool(polymorphic_inlining, true,"polymorphic inlining") DEFINE_bool(use_osr, true,"use on-stack replacement") DEFINE_bool(array_bounds_checks_elimination, false,"perform array bounds checks elimination") DEFINE_bool(array_index_dehoisting, false,"perform array index dehoisting") DEFINE_bool(trace_osr, false,"trace on-stack replacement") DEFINE_int(stress_runs, 0,"number of stress runs") DEFINE_bool(optimize_closures, true,"optimize closures") DEFINE_bool(inline_construct, true,"inline constructor calls") DEFINE_bool(inline_arguments, true,"inline functions with arguments object") DEFINE_int(loop_weight, 1,"loop weight for representation inference") DEFINE_bool(optimize_for_in, true,"optimize functions containing for-in loops") DEFINE_bool(experimental_profiler, true,"enable all profiler experiments") DEFINE_bool(watch_ic_patching, false,"profiler considers IC stability") DEFINE_int(frame_count, 1,"number of stack frames inspected by the profiler") DEFINE_bool(self_optimization, false,"primitive functions trigger their own optimization") DEFINE_bool(direct_self_opt, false,"call recompile stub directly when self-optimizing") DEFINE_bool(retry_self_opt, false,"re-try self-optimization if it failed") DEFINE_bool(count_based_interrupts, false,"trigger profiler ticks based on counting instead of timing") DEFINE_bool(interrupt_at_exit, false,"insert an interrupt check at function exit") DEFINE_bool(weighted_back_edges, false,"weight back edges by jump distance for interrupt triggering") DEFINE_int(interrupt_budget, 5900,"execution budget before interrupt is triggered") DEFINE_int(type_info_threshold, 15,"percentage of ICs that must have type info to allow optimization") DEFINE_int(self_opt_count, 130,"call count before self-optimization") DEFINE_implication(experimental_profiler, watch_ic_patching) DEFINE_implication(experimental_profiler, self_optimization) DEFINE_implication(experimental_profiler, retry_self_opt) DEFINE_implication(experimental_profiler, count_based_interrupts) DEFINE_implication(experimental_profiler, interrupt_at_exit) DEFINE_implication(experimental_profiler, weighted_back_edges) DEFINE_bool(trace_opt_verbose, false,"extra verbose compilation tracing") DEFINE_implication(trace_opt_verbose, trace_opt) DEFINE_bool(debug_code, false,"generate extra code (assertions) for debugging") DEFINE_bool(code_comments, false,"emit comments in code disassembly") DEFINE_bool(enable_sse2, true,"enable use of SSE2 instructions if available") DEFINE_bool(enable_sse3, true,"enable use of SSE3 instructions if available") DEFINE_bool(enable_sse4_1, true,"enable use of SSE4.1 instructions if available") DEFINE_bool(enable_cmov, true,"enable use of CMOV instruction if available") DEFINE_bool(enable_rdtsc, true,"enable use of RDTSC instruction if available") DEFINE_bool(enable_sahf, true,"enable use of SAHF instruction if available (X64 only)") DEFINE_bool(enable_vfp3, true,"enable use of VFP3 instructions if available - this implies ""enabling ARMv7 instructions (ARM only)") DEFINE_bool(enable_armv7, true,"enable use of ARMv7 instructions if available (ARM only)") DEFINE_bool(enable_fpu, true,"enable use of MIPS FPU instructions if available (MIPS only)") DEFINE_string(expose_natives_as, NULL,"expose natives in global object") DEFINE_string(expose_debug_as, NULL,"expose debug in global object") DEFINE_bool(expose_gc, false,"expose gc extension") DEFINE_bool(expose_externalize_string, false,"expose externalize string extension") DEFINE_int(stack_trace_limit, 10,"number of stack frames to capture") DEFINE_bool(builtins_in_stack_traces, false,"show built-in functions in stack traces") DEFINE_bool(disable_native_files, false,"disable builtin natives files") DEFINE_bool(inline_new, true,"use fast inline allocation") DEFINE_bool(stack_trace_on_abort, true,"print a stack trace if an assertion failure occurs") DEFINE_bool(trace, false,"trace function calls") DEFINE_bool(mask_constants_with_cookie, true,"use random jit cookie to mask large constants") DEFINE_bool(lazy, true,"use lazy compilation") DEFINE_bool(trace_opt, false,"trace lazy optimization") DEFINE_bool(trace_opt_stats, false,"trace lazy optimization statistics") DEFINE_bool(opt, true,"use adaptive optimizations") DEFINE_bool(always_opt, false,"always try to optimize functions") DEFINE_bool(prepare_always_opt, false,"prepare for turning on always opt") DEFINE_bool(trace_deopt, false,"trace deoptimization") DEFINE_int(min_preparse_length, 1024,"minimum length for automatic enable preparsing") DEFINE_bool(always_full_compiler, false,"try to use the dedicated run-once backend for all code") DEFINE_bool(trace_bailout, false,"print reasons for falling back to using the classic V8 backend") DEFINE_bool(compilation_cache, true,"enable compilation cache") DEFINE_bool(cache_prototype_transitions, true,"cache prototype transitions") DEFINE_bool(trace_debug_json, false,"trace debugging JSON request/response") DEFINE_bool(debugger_auto_break, true,"automatically set the debug break flag when debugger commands are ""in the queue") DEFINE_bool(enable_liveedit, true,"enable liveedit experimental feature") DEFINE_bool(break_on_abort, true,"always cause a debug break before aborting") DEFINE_int(stack_size, kPointerSize *123,"default size of stack region v8 is allowed to use (in kBytes)") DEFINE_int(max_stack_trace_source_length, 300,"maximum length of function source code printed in a stack trace.") DEFINE_bool(always_inline_smi_code, false,"always inline smi code in non-opt code") DEFINE_int(max_new_space_size, 0,"max size of the new generation (in kBytes)") DEFINE_int(max_old_space_size, 0,"max size of the old generation (in Mbytes)") DEFINE_int(max_executable_size, 0,"max size of executable memory (in Mbytes)") DEFINE_bool(gc_global, false,"always perform global GCs") DEFINE_int(gc_interval,-1,"garbage collect after <n> allocations") DEFINE_bool(trace_gc, false,"print one trace line following each garbage collection") DEFINE_bool(trace_gc_nvp, false,"print one detailed trace line in name=value format ""after each garbage collection") DEFINE_bool(print_cumulative_gc_stat, false,"print cumulative GC statistics in name=value format on exit") DEFINE_bool(trace_gc_verbose, false,"print more details following each garbage collection") DEFINE_bool(trace_fragmentation, false,"report fragmentation for old pointer and data pages") DEFINE_bool(collect_maps, true,"garbage collect maps from which no objects can be reached") DEFINE_bool(flush_code, true,"flush code that we expect not to use again before full gc") DEFINE_bool(incremental_marking, true,"use incremental marking") DEFINE_bool(incremental_marking_steps, true,"do incremental marking steps") DEFINE_bool(trace_incremental_marking, false,"trace progress of the incremental marking") DEFINE_bool(use_idle_notification, true,"Use idle notification to reduce memory footprint.") DEFINE_bool(send_idle_notification, false,"Send idle notifcation between stress runs.") DEFINE_bool(use_ic, true,"use inline caching") DEFINE_bool(native_code_counters, false,"generate extra code for manipulating stats counters") DEFINE_bool(always_compact, false,"Perform compaction on every full GC") DEFINE_bool(lazy_sweeping, true,"Use lazy sweeping for old pointer and data spaces") DEFINE_bool(never_compact, false,"Never perform compaction on full GC - testing only") DEFINE_bool(compact_code_space, true,"Compact code space on full non-incremental collections") DEFINE_bool(cleanup_code_caches_at_gc, true,"Flush inline caches prior to mark compact collection and ""flush code caches in maps during mark compact cycle.") DEFINE_int(random_seed, 0,"Default seed for initializing random generator ""(0, the default, means to use system random).") DEFINE_bool(use_verbose_printer, true,"allows verbose printing") DEFINE_bool(allow_natives_syntax, false,"allow natives syntax") DEFINE_bool(trace_sim, false,"Trace simulator execution") DEFINE_bool(check_icache, false,"Check icache flushes in ARM and MIPS simulator") DEFINE_int(stop_sim_at, 0,"Simulator stop after x number of instructions") DEFINE_int(sim_stack_alignment, 8,"Stack alingment in bytes in simulator (4 or 8, 8 is default)") DEFINE_bool(trace_exception, false,"print stack trace when throwing exceptions") DEFINE_bool(preallocate_message_memory, false,"preallocate some memory to build stack traces.") DEFINE_bool(randomize_hashes, true,"randomize hashes to avoid predictable hash collisions ""(with snapshots this option cannot override the baked-in seed)") DEFINE_int(hash_seed, 0,"Fixed seed to use to hash property keys (0 means random)""(with snapshots this option cannot override the baked-in seed)") DEFINE_bool(preemption, false,"activate a 100ms timer that switches between V8 threads") DEFINE_bool(regexp_optimization, true,"generate optimized regexp code") DEFINE_bool(testing_bool_flag, true,"testing_bool_flag") DEFINE_int(testing_int_flag, 13,"testing_int_flag") DEFINE_float(testing_float_flag, 2.5,"float-flag") DEFINE_string(testing_string_flag,"Hello, world!","string-flag") DEFINE_int(testing_prng_seed, 42,"Seed used for threading test randomness") DEFINE_string(testing_serialization_file,"/tmp/serdes","file in which to serialize heap") DEFINE_bool(help, false,"Print usage message, including flags, on console") DEFINE_bool(dump_counters, false,"Dump counters on exit") DEFINE_string(map_counters,"","Map counters to a file") DEFINE_args(js_arguments, JSARGUMENTS_INIT,"Pass all remaining arguments to the script. Alias for \"--\".") DEFINE_bool(debug_compile_events, true,"Enable debugger compile events") DEFINE_bool(debug_script_collected_events, true,"Enable debugger script collected events") DEFINE_bool(gdbjit, false,"enable GDBJIT interface (disables compacting GC)") DEFINE_bool(gdbjit_full, false,"enable GDBJIT interface for all code objects") DEFINE_bool(gdbjit_dump, false,"dump elf objects with debug info to disk") DEFINE_string(gdbjit_dump_filter,"","dump only objects containing this substring") DEFINE_bool(force_marking_deque_overflows, false,"force overflows of marking deque by reducing it's size ""to 64 words") DEFINE_bool(stress_compaction, false,"stress the GC compactor to flush out bugs (implies ""--force_marking_deque_overflows)")#define FLAG DEFINE_bool(enable_slow_asserts, false,"enable asserts that are slow to execute") DEFINE_bool(trace_codegen, false,"print name of functions for which code is generated") DEFINE_bool(print_source, false,"pretty print source code") DEFINE_bool(print_builtin_source, false,"pretty print source code for builtins") DEFINE_bool(print_ast, false,"print source AST") DEFINE_bool(print_builtin_ast, false,"print source AST for builtins") DEFINE_string(stop_at,"","function name where to insert a breakpoint") DEFINE_bool(print_builtin_scopes, false,"print scopes for builtins") DEFINE_bool(print_scopes, false,"print scopes") DEFINE_bool(trace_contexts, false,"trace contexts operations") DEFINE_bool(gc_greedy, false,"perform GC prior to some allocations") DEFINE_bool(gc_verbose, false,"print stuff during garbage collection") DEFINE_bool(heap_stats, false,"report heap statistics before and after GC") DEFINE_bool(code_stats, false,"report code statistics after GC") DEFINE_bool(verify_heap, false,"verify heap pointers before and after GC") DEFINE_bool(print_handles, false,"report handles after GC") DEFINE_bool(print_global_handles, false,"report global handles after GC") DEFINE_bool(trace_ic, false,"trace inline cache state transitions") DEFINE_bool(print_interfaces, false,"print interfaces") DEFINE_bool(print_interface_details, false,"print interface inference details") DEFINE_int(print_interface_depth, 5,"depth for printing interfaces") DEFINE_bool(trace_normalization, false,"prints when objects are turned into dictionaries.") DEFINE_bool(trace_lazy, false,"trace lazy compilation") DEFINE_bool(collect_heap_spill_statistics, false,"report heap spill statistics along with heap_stats ""(requires heap_stats)") DEFINE_bool(trace_isolates, false,"trace isolate state changes") DEFINE_bool(log_state_changes, false,"Log state changes.") DEFINE_bool(regexp_possessive_quantifier, false,"enable possessive quantifier syntax for testing") DEFINE_bool(trace_regexp_bytecodes, false,"trace regexp bytecode execution") DEFINE_bool(trace_regexp_assembler, false,"trace regexp macro assembler calls.")#define FLAG DEFINE_bool(log, false,"Minimal logging (no API, code, GC, suspect, or handles samples).") DEFINE_bool(log_all, false,"Log all events to the log file.") DEFINE_bool(log_runtime, false,"Activate runtime system %Log call.") DEFINE_bool(log_api, false,"Log API events to the log file.") DEFINE_bool(log_code, false,"Log code events to the log file without profiling.") DEFINE_bool(log_gc, false,"Log heap samples on garbage collection for the hp2ps tool.") DEFINE_bool(log_handles, false,"Log global handle events.") DEFINE_bool(log_snapshot_positions, false,"log positions of (de)serialized objects in the snapshot.") DEFINE_bool(log_suspect, false,"Log suspect operations.") DEFINE_bool(prof, false,"Log statistical profiling information (implies --log-code).") DEFINE_bool(prof_auto, true,"Used with --prof, starts profiling automatically") DEFINE_bool(prof_lazy, false,"Used with --prof, only does sampling and logging"" when profiler is active (implies --noprof_auto).") DEFINE_bool(prof_browser_mode, true,"Used with --prof, turns on browser-compatible mode for profiling.") DEFINE_bool(log_regexp, false,"Log regular expression execution.") DEFINE_bool(sliding_state_window, false,"Update sliding state window counters.") DEFINE_string(logfile,"v8.log","Specify the name of the log file.") DEFINE_bool(ll_prof, false,"Enable low-level linux profiler.")#define FLAG DEFINE_bool(trace_elements_transitions, false,"trace elements transitions") DEFINE_bool(print_code_stubs, false,"print code stubs") DEFINE_bool(test_secondary_stub_cache, false,"test secondary stub cache by disabling the primary one") DEFINE_bool(test_primary_stub_cache, false,"test primary stub cache by disabling the secondary one") DEFINE_bool(print_code, false,"print generated code") DEFINE_bool(print_opt_code, false,"print optimized code") DEFINE_bool(print_unopt_code, false,"print unoptimized code before ""printing optimized code based on it") DEFINE_bool(print_code_verbose, false,"print more information for code") DEFINE_bool(print_builtin_code, false,"print generated code for builtins")#47"/Users/thlorenz/dev/dx/v8-perf/build/v8/src/flags.cc"2 namespace{struct Flag{enum FlagType{TYPE_BOOL, TYPE_INT, TYPE_FLOAT, TYPE_STRING, TYPE_ARGS} name
static const int kGlobalReceiverOffset
static void GenerateGlobalProxy(MacroAssembler *masm, StrictModeFlag strict_mode)
static void GenerateMegamorphic(MacroAssembler *masm, StrictModeFlag strict_mode)
static void GenerateStringLength(MacroAssembler *masm, bool support_wrappers)
static const int kHasNamedInterceptor
static const int kIsAccessCheckNeeded
static uint32_t GetRs(Instr instr)
static void GenerateMegamorphic(MacroAssembler *masm)
#define ASSERT(condition)
const int kPointerSizeLog2
static const int kInstanceSizeOffset
Isolate * isolate() const
static const ExtraICState kNoExtraICState
void PatchInlinedSmiCode(Address address, InlinedSmiCheck check)
static void GenerateArrayLength(MacroAssembler *masm)
static const int kHashFieldOffset
static const int kHasIndexedInterceptor
void UpdateCaches(Handle< Object > x, Handle< Object > y)
static Condition ComputeCondition(Token::Value op)
STATIC_ASSERT((FixedDoubleArray::kHeaderSize &kDoubleAlignmentMask)==0)
const uint32_t kIsSymbolMask
static void GenerateGeneric(MacroAssembler *masm)
static void GenerateMiss(MacroAssembler *masm)
static bool decode(uint32_t value)
static const int kPropertiesOffset
static Register from_code(int code)
static const int kInObjectPropertiesOffset
static void GenerateSmiToDouble(MacroAssembler *masm, Label *fail)
static void GenerateMapChangeElementsTransition(MacroAssembler *masm)
static const int kElementsOffset
static const int kContainsCachedArrayIndexMask
static const int kCallTargetAddressOffset
STATIC_ASSERT(kGrowICDelta==STORE_AND_GROW_TRANSITION_SMI_TO_OBJECT-STORE_TRANSITION_SMI_TO_OBJECT)
static void GenerateMegamorphic(MacroAssembler *masm, int argc)
static const int kLengthOffset
static const int kHeaderSize
static void GenerateSlow(MacroAssembler *masm)
static void GenerateMiss(MacroAssembler *masm, int argc, Code::ExtraICState extra_state)
static const int kMapOffset
static void GenerateRuntimeSetProperty(MacroAssembler *masm, StrictModeFlag strict_mode)
static void GenerateDoubleToObject(MacroAssembler *masm, Label *fail)
static const int kLengthOffset
static const int kSlowCaseBitFieldMask
static void GenerateNormal(MacroAssembler *masm, int argc)
static void GeneratePositiveLookup(MacroAssembler *masm, Label *miss, Label *done, Register elements, Register name, Register r0, Register r1)
MemOperand FieldMemOperand(Register object, int offset)
static void GenerateMonomorphicCacheProbe(MacroAssembler *masm, int argc, Code::Kind kind, Code::ExtraICState extra_state)
static void GenerateString(MacroAssembler *masm)
static Flags ComputeFlags(Kind kind, InlineCacheState ic_state=UNINITIALIZED, ExtraICState extra_ic_state=kNoExtraICState, PropertyType type=NORMAL, int argc=-1, InlineCacheHolderFlag holder=OWN_MAP)
#define ASSERT_EQ(v1, v2)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination trace on stack replacement optimize closures functions with arguments object optimize functions containing for in loops profiler considers IC stability primitive functions trigger their own optimization re try self optimization if it failed insert an interrupt check at function exit execution budget before interrupt is triggered call count before self optimization self_optimization count_based_interrupts weighted_back_edges trace_opt emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 enable use of ARMv7 instructions if enable use of MIPS FPU instructions if NULL
static void GenerateNonStrictArguments(MacroAssembler *masm)
static void GenerateMegamorphic(MacroAssembler *masm, int argc, Code::ExtraICState extra_ic_state)
static void GenerateNormal(MacroAssembler *masm)
static bool IsBne(Instr instr)
static void GenerateFunctionPrototype(MacroAssembler *masm)
static void GenerateIndexedInterceptor(MacroAssembler *masm)
static bool IsBeq(Instr instr)
void set_target(Code *code)
const uint32_t kSymbolTag
static const int kCapacityMask
static void GenerateNonStrictArguments(MacroAssembler *masm)
static void GenerateMiss(MacroAssembler *masm, bool force_generic)
static void GenerateMiss(MacroAssembler *masm)
static void GenerateTransitionElementsSmiToDouble(MacroAssembler *masm)
static const int kHashShift
static void GenerateNonStrictArguments(MacroAssembler *masm, int argc)
static void GenerateArrayLength(MacroAssembler *masm)
static const char * GetStateName(State state)
void check(i::Vector< const char > string)
static const int kHashMask
static void GenerateMiss(MacroAssembler *masm, int argc)
static const int kInstanceTypeOffset
static const int kEntriesPerBucket
static bool IsAndImmediate(Instr instr)
static void GenerateNormal(MacroAssembler *masm)
static void GenerateMiss(MacroAssembler *masm, bool force_generic)