Fixed resizing of deopt table

src/deoptimizer.cc

 // 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
@@ skipping 1456 matching lines @@
 
 
 void Deoptimizer::AddDoubleValue(intptr_t slot_address, double value) {
   HeapNumberMaterializationDescriptor value_desc(
       reinterpret_cast<Address>(slot_address), value);
   deferred_heap_numbers_.Add(value_desc);
 }
 
 
 void Deoptimizer::EnsureCodeForDeoptimizationEntry(BailoutType type,
                                                    int max_entry_id) {

[palmer, 2012/12/18 20:33:41]

max_entry_id should be unsigned int (or, better, size_t), right?

[Sven Panne, 2012/12/19 07:34:58]

To be exact, neither of them: What we should really use here is a totally
separate type "DeoptimizationIndex", just like BailoutId or TypeFeedbackId,
which wraps an underlying integral type (for Haskellers: Use a newtype). If the
underlying integral type for this int, size_t or whatever doesn't really matter
that much, it depends on e.g. the fact how to handle "Maybe DeoptimizationIndex"
in Haskell-speak.

This might be a worthwhile refactoring, but should be done in a separate CL. It
is a real, real pity that we don't use such wrapped integral types much more
often, that would have avoided tons of portability and maintenance problems and
would be extremely beneficial for code readability.

   // We cannot run this if the serializer is enabled because this will
   // cause us to emit relocation information for the external
   // references. This is fine because the deoptimizer's code section
   // isn't meant to be serialized at all.
   ASSERT(!Serializer::enabled());
 
   ASSERT(type == EAGER || type == LAZY);
   DeoptimizerData* data = Isolate::Current()->deoptimizer_data();
   int entry_count = (type == EAGER)
       ? data->eager_deoptimization_entry_code_entries_
       : data->lazy_deoptimization_entry_code_entries_;
   if (max_entry_id < entry_count) return;
-  entry_count = Min(Max(entry_count * 2, Deoptimizer::kMinNumberOfEntries),
-                    Deoptimizer::kMaxNumberOfEntries);
+  entry_count = Max(entry_count, Deoptimizer::kMinNumberOfEntries);
+  while (max_entry_id >= entry_count) entry_count *= 2;

[palmer, 2012/12/18 20:33:41]

Risk of integer overflow? And why not use unsigned int here? (size_t is best)

[Sven Panne, 2012/12/19 07:34:58]

Regarding typing: See above. Regarding overflow: Can't happen, see call sites,
perhaps another assertion might make this clearer, but I'll leave it for now as
it is.

+  ASSERT(entry_count <= Deoptimizer::kMaxNumberOfEntries);
 
   MacroAssembler masm(Isolate::Current(), NULL, 16 * KB);
   masm.set_emit_debug_code(false);
   GenerateDeoptimizationEntries(&masm, entry_count, type);
   CodeDesc desc;
   masm.GetCode(&desc);
   ASSERT(desc.reloc_size == 0);
 
   VirtualMemory* memory = type == EAGER
       ? data->eager_deoptimization_entry_code_
@@ skipping 563 matching lines @@
 
 void DeoptimizedFrameInfo::Iterate(ObjectVisitor* v) {
   v->VisitPointer(BitCast<Object**>(&function_));
   v->VisitPointers(parameters_, parameters_ + parameters_count_);
   v->VisitPointers(expression_stack_, expression_stack_ + expression_count_);
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 } }  // namespace v8::internal