void CodeGenerator::GenerateFastCaseSwitchJumpTable(
- SwitchStatement* node, int min_index, int range, Label *fail_label,
- SmartPointer<Label*> &case_targets, SmartPointer<Label> &case_labels) {
+ SwitchStatement* node,
+ int min_index,
+ int range,
+ Label* fail_label,
+ Vector<Label*> case_targets,
+ Vector<Label> case_labels) {
ASSERT(kSmiTag == 0 && kSmiTagSize <= 2);
// Allocate a jump table and create code to jump through it.
// Should call GenerateFastCaseSwitchCases to generate the code for
// all the cases at the appropriate point.
- void GenerateFastCaseSwitchJumpTable(SwitchStatement* node, int min_index,
- int range, Label *fail_label,
- SmartPointer<Label*> &case_targets,
- SmartPointer<Label>& case_labels);
+ void GenerateFastCaseSwitchJumpTable(SwitchStatement* node,
+ int min_index,
+ int range,
+ Label* fail_label,
+ Vector<Label*> case_targets,
+ Vector<Label> case_labels);
// Generate the code for cases for the fast case switch.
// Called by GenerateFastCaseSwitchJumpTable.
void GenerateFastCaseSwitchCases(SwitchStatement* node,
- SmartPointer<Label> &case_labels);
+ Vector<Label> case_labels);
// Fast support for constant-Smi switches.
- void GenerateFastCaseSwitchStatement(SwitchStatement *node, int min_index,
- int range, int default_index);
+ void GenerateFastCaseSwitchStatement(SwitchStatement* node,
+ int min_index,
+ int range,
+ int default_index);
// Fast support for constant-Smi switches. Tests whether switch statement
// permits optimization and calls GenerateFastCaseSwitch if it does.
// Returns true if the fast-case switch was generated, and false if not.
- bool TryGenerateFastCaseSwitchStatement(SwitchStatement *node);
+ bool TryGenerateFastCaseSwitchStatement(SwitchStatement* node);
// Bottle-neck interface to call the Assembler to generate the statement
// Generate a computed jump to a switch case.
void CodeGenerator::GenerateFastCaseSwitchJumpTable(
- SwitchStatement* node, int min_index, int range, Label *fail_label,
- SmartPointer<Label*> &case_targets, SmartPointer<Label> &case_labels) {
+ SwitchStatement* node,
+ int min_index,
+ int range,
+ Label* fail_label,
+ Vector<Label*> case_targets,
+ Vector<Label> case_labels) {
// Notice: Internal references, used by both the jmp instruction and
// the table entries, need to be relocated if the buffer grows. This
// prevents the forward use of Labels, since a displacement cannot
// Allocate a jump table and create code to jump through it.
// Should call GenerateFastCaseSwitchCases to generate the code for
// all the cases at the appropriate point.
- void GenerateFastCaseSwitchJumpTable(SwitchStatement* node, int min_index,
- int range, Label *fail_label,
- SmartPointer<Label*> &case_targets,
- SmartPointer<Label>& case_labels);
+ void GenerateFastCaseSwitchJumpTable(SwitchStatement* node,
+ int min_index,
+ int range,
+ Label* fail_label,
+ Vector<Label*> case_targets,
+ Vector<Label> case_labels);
// Generate the code for cases for the fast case switch.
// Called by GenerateFastCaseSwitchJumpTable.
void GenerateFastCaseSwitchCases(SwitchStatement* node,
- SmartPointer<Label> &case_labels);
+ Vector<Label> case_labels);
// Fast support for constant-Smi switches.
- void GenerateFastCaseSwitchStatement(SwitchStatement *node, int min_index,
- int range, int default_index);
+ void GenerateFastCaseSwitchStatement(SwitchStatement* node,
+ int min_index,
+ int range,
+ int default_index);
// Fast support for constant-Smi switches. Tests whether switch statement
// permits optimization and calls GenerateFastCaseSwitch if it does.
// Returns true if the fast-case switch was generated, and false if not.
- bool TryGenerateFastCaseSwitchStatement(SwitchStatement *node);
+ bool TryGenerateFastCaseSwitchStatement(SwitchStatement* node);
// Bottle-neck interface to call the Assembler to generate the statement
}
}
- GenerateFastCaseSwitchJumpTable(node, min_index, range, fail_label,
- case_targets, case_labels);
+ GenerateFastCaseSwitchJumpTable(node,
+ min_index,
+ range,
+ fail_label,
+ Vector<Label*>(*case_targets, range),
+ Vector<Label>(*case_labels, length));
}
void CodeGenerator::GenerateFastCaseSwitchCases(
SwitchStatement* node,
- SmartPointer<Label>& case_labels) {
+ Vector<Label> case_labels) {
ZoneList<CaseClause*>* cases = node->cases();
int length = cases->length();
Object* Map::CopyDropTransitions() {
- Object *new_map = Copy();
+ Object* new_map = Copy();
if (new_map->IsFailure()) return new_map;
Object* descriptors = instance_descriptors()->RemoveTransitions();
if (descriptors->IsFailure()) return descriptors;
entry.set_contains_array_literal(contains_array_literal);
}
- FunctionLiteral *function_literal =
+ FunctionLiteral* function_literal =
NEW(FunctionLiteral(name, top_scope_,
body.elements(), materialized_literal_count,
contains_array_literal, expected_property_count,
static Handle<Map> ComputeObjectLiteralMap(
Handle<Context> context,
Handle<FixedArray> constant_properties,
- bool &is_result_from_cache) {
+ bool* is_result_from_cache) {
if (FLAG_canonicalize_object_literal_maps) {
// First find prefix of consecutive symbol keys.
int number_of_properties = constant_properties->length()/2;
for (int i = 0; i < number_of_symbol_keys; i++) {
keys->set(i, constant_properties->get(i*2));
}
- is_result_from_cache = true;
+ *is_result_from_cache = true;
return Factory::ObjectLiteralMapFromCache(context, keys);
}
}
- is_result_from_cache = false;
+ *is_result_from_cache = false;
return Handle<Map>(context->object_function()->initial_map());
}
bool is_result_from_cache;
Handle<Map> map = ComputeObjectLiteralMap(context,
constant_properties,
- is_result_from_cache);
+ &is_result_from_cache);
Handle<JSObject> boilerplate = Factory::NewJSObjectFromMap(map);
{ // Add the constant propeties to the boilerplate.
private:
int suffixes_[kBMMaxShift + 1];
int good_suffix_shift_[kBMMaxShift + 1];
- int *biased_suffixes_;
- int *biased_good_suffix_shift_;
+ int* biased_suffixes_;
+ int* biased_good_suffix_shift_;
DISALLOW_COPY_AND_ASSIGN(BMGoodSuffixBuffers);
};
static int BoyerMooreSimplified(Vector<const schar> subject,
Vector<const pchar> pattern,
int start_index,
- bool& complete) {
+ bool* complete) {
int n = subject.length();
int m = pattern.length();
// Only preprocess at most kBMMaxShift last characters of pattern.
idx += shift;
badness += 1 - shift; // at most zero, so badness cannot increase.
if (idx > n - m) {
- complete = true;
+ *complete = true;
return -1;
}
}
j--;
while (j >= 0 && pattern[j] == (c = subject[idx + j])) j--;
if (j < 0) {
- complete = true;
+ *complete = true;
return idx;
} else {
int bc_occ = CharOccurence<schar, pchar>(c);
// compared to reading each character exactly once.
badness += (m - j) - shift;
if (badness > 0) {
- complete = false;
+ *complete = false;
return idx;
}
}
}
- complete = true;
+ *complete = true;
return -1;
}
static int SimpleIndexOf(Vector<const schar> subject,
Vector<const pchar> pattern,
int idx,
- bool &complete) {
+ bool* complete) {
// Badness is a count of how much work we have done. When we have
// done enough work we decide it's probably worth switching to a better
// algorithm.
for (int i = idx, n = subject.length() - pattern.length(); i <= n; i++) {
badness++;
if (badness > 0) {
- complete = false;
+ *complete = false;
return (i);
}
if (subject[i] != pattern_first_char) continue;
j++;
} while (j < pattern.length());
if (j == pattern.length()) {
- complete = true;
+ *complete = true;
return i;
}
badness += j;
}
- complete = true;
+ *complete = true;
return -1;
}
}
// Try algorithms in order of increasing setup cost and expected performance.
bool complete;
- int idx = SimpleIndexOf(sub, pat, start_index, complete);
+ int idx = SimpleIndexOf(sub, pat, start_index, &complete);
if (complete) return idx;
- idx = BoyerMooreSimplified(sub, pat, idx, complete);
+ idx = BoyerMooreSimplified(sub, pat, idx, &complete);
if (complete) return idx;
return BoyerMooreIndexOf(sub, pat, idx);
}
}
-bool Serializer::IsVisited(HeapObject *obj) {
+bool Serializer::IsVisited(HeapObject* obj) {
HashMap::Entry* entry =
saved_addresses_.Lookup(obj, HeapObjectHash(obj), false);
return entry != NULL;
}
-Address Serializer::GetSavedAddress(HeapObject *obj) {
+Address Serializer::GetSavedAddress(HeapObject* obj) {
HashMap::Entry* entry
= saved_addresses_.Lookup(obj, HeapObjectHash(obj), false);
ASSERT(entry != NULL);
// Get a raw object of the right size in the right space.
AllocationSpace space = GetSpace(a);
- Object *o;
+ Object* o;
if (IsLargeExecutableObject(a)) {
o = Heap::lo_space()->AllocateRawCode(size);
} else if (IsLargeFixedArray(a)) {
template<typename T>
-void ConcatReversed(List<T> * target, const List<T> & source) {
+void ConcatReversed(List<T>* target, const List<T>& source) {
for (int i = source.length() - 1; i >= 0; i--) {
target->Add(source[i]);
}
virtual void VisitPointers(Object** start, Object** end);
- bool IsVisited(HeapObject *obj);
+ bool IsVisited(HeapObject* obj);
- Address GetSavedAddress(HeapObject *obj);
+ Address GetSavedAddress(HeapObject* obj);
void SaveAddress(HeapObject* obj, Address addr);