| Index: src/sh4/regexp-macro-assembler-sh4.cc
|
| diff --git a/src/arm/regexp-macro-assembler-arm.cc b/src/sh4/regexp-macro-assembler-sh4.cc
|
| similarity index 73%
|
| copy from src/arm/regexp-macro-assembler-arm.cc
|
| copy to src/sh4/regexp-macro-assembler-sh4.cc
|
| index 17b867784251a15a218c75c5e806b6c6724484a8..56dde7eb6fba5738eb443844002ad2db6a4afb17 100644
|
| --- a/src/arm/regexp-macro-assembler-arm.cc
|
| +++ b/src/sh4/regexp-macro-assembler-sh4.cc
|
| @@ -1,4 +1,4 @@
|
| -// Copyright 2012 the V8 project authors. All rights reserved.
|
| +// Copyright 2011-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:
|
| @@ -27,7 +27,7 @@
|
|
|
| #include "v8.h"
|
|
|
| -#if defined(V8_TARGET_ARCH_ARM)
|
| +#if defined(V8_TARGET_ARCH_SH4)
|
|
|
| #include "unicode.h"
|
| #include "log.h"
|
| @@ -35,11 +35,13 @@
|
| #include "regexp-stack.h"
|
| #include "macro-assembler.h"
|
| #include "regexp-macro-assembler.h"
|
| -#include "arm/regexp-macro-assembler-arm.h"
|
| +#include "sh4/regexp-macro-assembler-sh4.h"
|
|
|
| namespace v8 {
|
| namespace internal {
|
|
|
| +#include "map-sh4.h" // For ARM -> SH4 register mapping
|
| +
|
| #ifndef V8_INTERPRETED_REGEXP
|
| /*
|
| * This assembler uses the following register assignment convention
|
| @@ -50,30 +52,29 @@ namespace internal {
|
| * Please notice that this is the byte offset, not the character offset!
|
| * - r7 : Currently loaded character. Must be loaded using
|
| * LoadCurrentCharacter before using any of the dispatch methods.
|
| - * - r8 : Points to tip of backtrack stack
|
| - * - r9 : Unused, might be used by C code and expected unchanged.
|
| - * - r10 : End of input (points to byte after last character in input).
|
| - * - r11 : Frame pointer. Used to access arguments, local variables and
|
| + * - r8 : points to tip of backtrack stack
|
| + * - r9 : End of input (points to byte after last character in input).
|
| + * - fp : Frame pointer. Used to access arguments, local variables and
|
| * RegExp registers.
|
| - * - r12 : IP register, used by assembler. Very volatile.
|
| - * - r13/sp : Points to tip of C stack.
|
| + * - r10 : IP register, used by assembler. Very volatile.
|
| + * - sp : points to tip of C stack.
|
| *
|
| * The remaining registers are free for computations.
|
| * Each call to a public method should retain this convention.
|
| *
|
| * The stack will have the following structure:
|
| - * - fp[56] Isolate* isolate (address of the current isolate)
|
| - * - fp[52] direct_call (if 1, direct call from JavaScript code,
|
| - * if 0, call through the runtime system).
|
| - * - fp[48] stack_area_base (high end of the memory area to use as
|
| - * backtracking stack).
|
| - * - fp[44] capture array size (may fit multiple sets of matches)
|
| - * - fp[40] int* capture_array (int[num_saved_registers_], for output).
|
| - * - fp[36] secondary link/return address used by native call.
|
| + * - fp[62] Isolate* isolate (Address of the current isolate)
|
| + * - fp[58] direct_call (if 1, direct call from JavaScript code,
|
| + * if 0, call through the runtime system).
|
| + * - fp[54] stack_area_base (High end of the memory area to use as
|
| + * backtracking stack).
|
| + * - fp[50] capture array size (may fit multiple sets of matches)
|
| + * - fp[46] int* capture_array (int[num_saved_registers_], for output).
|
| + * - fp[32] secondary link/return address used by native call.
|
| * --- sp when called ---
|
| - * - fp[32] return address (lr).
|
| - * - fp[28] old frame pointer (r11).
|
| - * - fp[0..24] backup of registers r4..r10.
|
| + * - fp[28] return address (pr).
|
| + * - fp[24] old frame pointer (r14).
|
| + * - fp[0..20] backup of registers r8..r13.
|
| * --- frame pointer ----
|
| * - fp[-4] end of input (address of end of string).
|
| * - fp[-8] start of input (address of first character in string).
|
| @@ -108,7 +109,7 @@ namespace internal {
|
| * bool direct_call = false)
|
| * The call is performed by NativeRegExpMacroAssembler::Execute()
|
| * (in regexp-macro-assembler.cc) via the CALL_GENERATED_REGEXP_CODE macro
|
| - * in arm/simulator-arm.h.
|
| + * in sh4/simulator-sh4.h.
|
| * When calling as a non-direct call (i.e., from C++ code), the return address
|
| * area is overwritten with the LR register by the RegExp code. When doing a
|
| * direct call from generated code, the return address is placed there by
|
| @@ -117,7 +118,7 @@ namespace internal {
|
|
|
| #define __ ACCESS_MASM(masm_)
|
|
|
| -RegExpMacroAssemblerARM::RegExpMacroAssemblerARM(
|
| +RegExpMacroAssemblerSH4::RegExpMacroAssemblerSH4(
|
| Mode mode,
|
| int registers_to_save,
|
| Zone* zone)
|
| @@ -133,12 +134,11 @@ RegExpMacroAssemblerARM::RegExpMacroAssemblerARM(
|
| exit_label_() {
|
| ASSERT_EQ(0, registers_to_save % 2);
|
| __ jmp(&entry_label_); // We'll write the entry code later.
|
| - EmitBacktrackConstantPool();
|
| __ bind(&start_label_); // And then continue from here.
|
| }
|
|
|
|
|
| -RegExpMacroAssemblerARM::~RegExpMacroAssemblerARM() {
|
| +RegExpMacroAssemblerSH4::~RegExpMacroAssemblerSH4() {
|
| delete masm_;
|
| // Unuse labels in case we throw away the assembler without calling GetCode.
|
| entry_label_.Unuse();
|
| @@ -151,12 +151,12 @@ RegExpMacroAssemblerARM::~RegExpMacroAssemblerARM() {
|
| }
|
|
|
|
|
| -int RegExpMacroAssemblerARM::stack_limit_slack() {
|
| +int RegExpMacroAssemblerSH4::stack_limit_slack() {
|
| return RegExpStack::kStackLimitSlack;
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::AdvanceCurrentPosition(int by) {
|
| +void RegExpMacroAssemblerSH4::AdvanceCurrentPosition(int by) {
|
| if (by != 0) {
|
| __ add(current_input_offset(),
|
| current_input_offset(), Operand(by * char_size()));
|
| @@ -164,7 +164,7 @@ void RegExpMacroAssemblerARM::AdvanceCurrentPosition(int by) {
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::AdvanceRegister(int reg, int by) {
|
| +void RegExpMacroAssemblerSH4::AdvanceRegister(int reg, int by) {
|
| ASSERT(reg >= 0);
|
| ASSERT(reg < num_registers_);
|
| if (by != 0) {
|
| @@ -175,32 +175,33 @@ void RegExpMacroAssemblerARM::AdvanceRegister(int reg, int by) {
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::Backtrack() {
|
| +void RegExpMacroAssemblerSH4::Backtrack() {
|
| CheckPreemption();
|
| // Pop Code* offset from backtrack stack, add Code* and jump to location.
|
| Pop(r0);
|
| - __ add(pc, r0, Operand(code_pointer()));
|
| + __ add(r0, r0, code_pointer());
|
| + __ jmp(r0);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::Bind(Label* label) {
|
| +void RegExpMacroAssemblerSH4::Bind(Label* label) {
|
| __ bind(label);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckCharacter(uint32_t c, Label* on_equal) {
|
| +void RegExpMacroAssemblerSH4::CheckCharacter(uint32_t c, Label* on_equal) {
|
| __ cmp(current_character(), Operand(c));
|
| BranchOrBacktrack(eq, on_equal);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckCharacterGT(uc16 limit, Label* on_greater) {
|
| - __ cmp(current_character(), Operand(limit));
|
| - BranchOrBacktrack(gt, on_greater);
|
| +void RegExpMacroAssemblerSH4::CheckCharacterGT(uc16 limit, Label* on_greater) {
|
| + __ cmpgt(current_character(), Operand(limit));
|
| + BranchOrBacktrack(eq, on_greater);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckAtStart(Label* on_at_start) {
|
| +void RegExpMacroAssemblerSH4::CheckAtStart(Label* on_at_start) {
|
| Label not_at_start;
|
| // Did we start the match at the start of the string at all?
|
| __ ldr(r0, MemOperand(frame_pointer(), kStartIndex));
|
| @@ -209,33 +210,33 @@ void RegExpMacroAssemblerARM::CheckAtStart(Label* on_at_start) {
|
|
|
| // If we did, are we still at the start of the input?
|
| __ ldr(r1, MemOperand(frame_pointer(), kInputStart));
|
| - __ add(r0, end_of_input_address(), Operand(current_input_offset()));
|
| + __ add(r0, end_of_input_address(), current_input_offset());
|
| __ cmp(r0, r1);
|
| BranchOrBacktrack(eq, on_at_start);
|
| __ bind(¬_at_start);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckNotAtStart(Label* on_not_at_start) {
|
| +void RegExpMacroAssemblerSH4::CheckNotAtStart(Label* on_not_at_start) {
|
| // Did we start the match at the start of the string at all?
|
| __ ldr(r0, MemOperand(frame_pointer(), kStartIndex));
|
| __ cmp(r0, Operand(0, RelocInfo::NONE));
|
| BranchOrBacktrack(ne, on_not_at_start);
|
| // If we did, are we still at the start of the input?
|
| __ ldr(r1, MemOperand(frame_pointer(), kInputStart));
|
| - __ add(r0, end_of_input_address(), Operand(current_input_offset()));
|
| + __ add(r0, end_of_input_address(), current_input_offset());
|
| __ cmp(r0, r1);
|
| BranchOrBacktrack(ne, on_not_at_start);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckCharacterLT(uc16 limit, Label* on_less) {
|
| - __ cmp(current_character(), Operand(limit));
|
| - BranchOrBacktrack(lt, on_less);
|
| +void RegExpMacroAssemblerSH4::CheckCharacterLT(uc16 limit, Label* on_less) {
|
| + __ cmpge(current_character(), Operand(limit));
|
| + BranchOrBacktrack(ne, on_less);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckCharacters(Vector<const uc16> str,
|
| +void RegExpMacroAssemblerSH4::CheckCharacters(Vector<const uc16> str,
|
| int cp_offset,
|
| Label* on_failure,
|
| bool check_end_of_string) {
|
| @@ -250,7 +251,7 @@ void RegExpMacroAssemblerARM::CheckCharacters(Vector<const uc16> str,
|
| CheckPosition(cp_offset + str.length() - 1, on_failure);
|
| }
|
|
|
| - __ add(r0, end_of_input_address(), Operand(current_input_offset()));
|
| + __ add(r0, end_of_input_address(), current_input_offset());
|
| if (cp_offset != 0) {
|
| int byte_offset = cp_offset * char_size();
|
| __ add(r0, r0, Operand(byte_offset));
|
| @@ -260,11 +261,13 @@ void RegExpMacroAssemblerARM::CheckCharacters(Vector<const uc16> str,
|
| int stored_high_byte = 0;
|
| for (int i = 0; i < str.length(); i++) {
|
| if (mode_ == ASCII) {
|
| - __ ldrb(r1, MemOperand(r0, char_size(), PostIndex));
|
| + __ ldrb(r1, MemOperand(r0));
|
| + __ add(r0, r0, Operand(char_size()));
|
| ASSERT(str[i] <= String::kMaxAsciiCharCode);
|
| __ cmp(r1, Operand(str[i]));
|
| } else {
|
| - __ ldrh(r1, MemOperand(r0, char_size(), PostIndex));
|
| + __ ldrh(r1, MemOperand(r0));
|
| + __ add(r0, r0, Operand(char_size()));
|
| uc16 match_char = str[i];
|
| int match_high_byte = (match_char >> 8);
|
| if (match_high_byte == 0) {
|
| @@ -283,30 +286,34 @@ void RegExpMacroAssemblerARM::CheckCharacters(Vector<const uc16> str,
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckGreedyLoop(Label* on_equal) {
|
| +void RegExpMacroAssemblerSH4::CheckGreedyLoop(Label* on_equal) {
|
| __ ldr(r0, MemOperand(backtrack_stackpointer(), 0));
|
| __ cmp(current_input_offset(), r0);
|
| + Label skip;
|
| + __ b(ne, &skip, Label::kNear);
|
| __ add(backtrack_stackpointer(),
|
| - backtrack_stackpointer(), Operand(kPointerSize), LeaveCC, eq);
|
| + backtrack_stackpointer(), Operand(kPointerSize));
|
| + __ bind(&skip);
|
| BranchOrBacktrack(eq, on_equal);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckNotBackReferenceIgnoreCase(
|
| +void RegExpMacroAssemblerSH4::CheckNotBackReferenceIgnoreCase(
|
| int start_reg,
|
| Label* on_no_match) {
|
| Label fallthrough;
|
| __ ldr(r0, register_location(start_reg)); // Index of start of capture
|
| __ ldr(r1, register_location(start_reg + 1)); // Index of end of capture
|
| - __ sub(r1, r1, r0, SetCC); // Length of capture.
|
| + __ sub(r1, r1, r0); // Length of capture.
|
| + __ tst(r1, r1);
|
|
|
| // If length is zero, either the capture is empty or it is not participating.
|
| // In either case succeed immediately.
|
| __ b(eq, &fallthrough);
|
|
|
| // Check that there are enough characters left in the input.
|
| - __ cmn(r1, Operand(current_input_offset()));
|
| - BranchOrBacktrack(gt, on_no_match);
|
| + __ cmpgt(r1, current_input_offset());
|
| + BranchOrBacktrack(ne, on_no_match);
|
|
|
| if (mode_ == ASCII) {
|
| Label success;
|
| @@ -315,9 +322,9 @@ void RegExpMacroAssemblerARM::CheckNotBackReferenceIgnoreCase(
|
|
|
| // r0 - offset of start of capture
|
| // r1 - length of capture
|
| - __ add(r0, r0, Operand(end_of_input_address()));
|
| - __ add(r2, end_of_input_address(), Operand(current_input_offset()));
|
| - __ add(r1, r0, Operand(r1));
|
| + __ add(r0, r0, end_of_input_address());
|
| + __ add(r2, end_of_input_address(), current_input_offset());
|
| + __ add(r1, r0, r1);
|
|
|
| // r0 - Address of start of capture.
|
| // r1 - Address of end of capture
|
| @@ -325,8 +332,10 @@ void RegExpMacroAssemblerARM::CheckNotBackReferenceIgnoreCase(
|
|
|
| Label loop;
|
| __ bind(&loop);
|
| - __ ldrb(r3, MemOperand(r0, char_size(), PostIndex));
|
| - __ ldrb(r4, MemOperand(r2, char_size(), PostIndex));
|
| + __ ldrb(r3, MemOperand(r0));
|
| + __ add(r0, r0, Operand(char_size()));
|
| + __ ldrb(r4, MemOperand(r2));
|
| + __ add(r2, r2, Operand(char_size()));
|
| __ cmp(r4, r3);
|
| __ b(eq, &loop_check);
|
|
|
| @@ -336,13 +345,13 @@ void RegExpMacroAssemblerARM::CheckNotBackReferenceIgnoreCase(
|
| __ cmp(r4, r3);
|
| __ b(ne, &fail);
|
| __ sub(r3, r3, Operand('a'));
|
| - __ cmp(r3, Operand('z' - 'a')); // Is r3 a lowercase letter?
|
| - __ b(hi, &fail);
|
| + __ cmphi(r3, Operand('z' - 'a')); // Is r3 a lowercase letter?
|
| + __ b(eq, &fail);
|
|
|
|
|
| __ bind(&loop_check);
|
| - __ cmp(r0, r1);
|
| - __ b(lt, &loop);
|
| + __ cmpge(r0, r1);
|
| + __ b(ne, &loop);
|
| __ jmp(&success);
|
|
|
| __ bind(&fail);
|
| @@ -366,36 +375,37 @@ void RegExpMacroAssemblerARM::CheckNotBackReferenceIgnoreCase(
|
| // r2: size_t byte_length - length of capture in bytes(!)
|
| // r3: Isolate* isolate
|
|
|
| + __ Push(r4, r5, r6, r7);
|
| // Address of start of capture.
|
| - __ add(r0, r0, Operand(end_of_input_address()));
|
| - // Length of capture.
|
| - __ mov(r2, Operand(r1));
|
| - // Save length in callee-save register for use on return.
|
| - __ mov(r4, Operand(r1));
|
| + __ add(r4, r0, end_of_input_address());
|
| // Address of current input position.
|
| - __ add(r1, current_input_offset(), Operand(end_of_input_address()));
|
| + __ add(r5, current_input_offset(), end_of_input_address());
|
| + // Length of capture.
|
| + __ mov(r6, r1);
|
| + // Save length on stack for use on return.
|
| + __ push(r1);
|
| // Isolate.
|
| - __ mov(r3, Operand(ExternalReference::isolate_address()));
|
| + __ mov(r7, Operand(ExternalReference::isolate_address()));
|
|
|
| - {
|
| - AllowExternalCallThatCantCauseGC scope(masm_);
|
| - ExternalReference function =
|
| - ExternalReference::re_case_insensitive_compare_uc16(masm_->isolate());
|
| - __ CallCFunction(function, argument_count);
|
| - }
|
| + ExternalReference function =
|
| + ExternalReference::re_case_insensitive_compare_uc16(masm_->isolate());
|
| + __ CallCFunction(function, argument_count);
|
| +
|
| + __ pop(r1);
|
| + __ Pop(r4, r5, r6, r7);
|
|
|
| // Check if function returned non-zero for success or zero for failure.
|
| __ cmp(r0, Operand(0, RelocInfo::NONE));
|
| BranchOrBacktrack(eq, on_no_match);
|
| // On success, increment position by length of capture.
|
| - __ add(current_input_offset(), current_input_offset(), Operand(r4));
|
| + __ add(current_input_offset(), current_input_offset(), r1);
|
| }
|
|
|
| __ bind(&fallthrough);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckNotBackReference(
|
| +void RegExpMacroAssemblerSH4::CheckNotBackReference(
|
| int start_reg,
|
| Label* on_no_match) {
|
| Label fallthrough;
|
| @@ -404,33 +414,38 @@ void RegExpMacroAssemblerARM::CheckNotBackReference(
|
| // Find length of back-referenced capture.
|
| __ ldr(r0, register_location(start_reg));
|
| __ ldr(r1, register_location(start_reg + 1));
|
| - __ sub(r1, r1, r0, SetCC); // Length to check.
|
| + __ sub(r1, r1, r0); // Length to check.
|
| + __ tst(r1, r1);
|
| // Succeed on empty capture (including no capture).
|
| __ b(eq, &fallthrough);
|
|
|
| // Check that there are enough characters left in the input.
|
| - __ cmn(r1, Operand(current_input_offset()));
|
| - BranchOrBacktrack(gt, on_no_match);
|
| + __ cmpgt(r1, current_input_offset());
|
| + BranchOrBacktrack(ne, on_no_match);
|
|
|
| // Compute pointers to match string and capture string
|
| - __ add(r0, r0, Operand(end_of_input_address()));
|
| - __ add(r2, end_of_input_address(), Operand(current_input_offset()));
|
| - __ add(r1, r1, Operand(r0));
|
| + __ add(r0, r0, end_of_input_address());
|
| + __ add(r2, end_of_input_address(), current_input_offset());
|
| + __ add(r1, r1, r0);
|
|
|
| Label loop;
|
| __ bind(&loop);
|
| if (mode_ == ASCII) {
|
| - __ ldrb(r3, MemOperand(r0, char_size(), PostIndex));
|
| - __ ldrb(r4, MemOperand(r2, char_size(), PostIndex));
|
| + __ ldrb(r3, MemOperand(r0));
|
| + __ add(r0, r0, Operand(char_size()));
|
| + __ ldrb(r4, MemOperand(r2));
|
| + __ add(r2, r2, Operand(char_size()));
|
| } else {
|
| ASSERT(mode_ == UC16);
|
| - __ ldrh(r3, MemOperand(r0, char_size(), PostIndex));
|
| - __ ldrh(r4, MemOperand(r2, char_size(), PostIndex));
|
| + __ ldrh(r3, MemOperand(r0));
|
| + __ add(r0, r0, Operand(char_size()));
|
| + __ ldrh(r4, MemOperand(r2));
|
| + __ add(r2, r2, Operand(char_size()));
|
| }
|
| __ cmp(r3, r4);
|
| BranchOrBacktrack(ne, on_no_match);
|
| - __ cmp(r0, r1);
|
| - __ b(lt, &loop);
|
| + __ cmpge(r0, r1);
|
| + __ b(ne, &loop);
|
|
|
| // Move current character position to position after match.
|
| __ sub(current_input_offset(), r2, end_of_input_address());
|
| @@ -438,78 +453,78 @@ void RegExpMacroAssemblerARM::CheckNotBackReference(
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckNotCharacter(unsigned c,
|
| +void RegExpMacroAssemblerSH4::CheckNotCharacter(unsigned c,
|
| Label* on_not_equal) {
|
| __ cmp(current_character(), Operand(c));
|
| BranchOrBacktrack(ne, on_not_equal);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckCharacterAfterAnd(uint32_t c,
|
| +void RegExpMacroAssemblerSH4::CheckCharacterAfterAnd(uint32_t c,
|
| uint32_t mask,
|
| Label* on_equal) {
|
| if (c == 0) {
|
| __ tst(current_character(), Operand(mask));
|
| } else {
|
| - __ and_(r0, current_character(), Operand(mask));
|
| + __ land(r0, current_character(), Operand(mask));
|
| __ cmp(r0, Operand(c));
|
| }
|
| BranchOrBacktrack(eq, on_equal);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckNotCharacterAfterAnd(unsigned c,
|
| +void RegExpMacroAssemblerSH4::CheckNotCharacterAfterAnd(unsigned c,
|
| unsigned mask,
|
| Label* on_not_equal) {
|
| if (c == 0) {
|
| __ tst(current_character(), Operand(mask));
|
| } else {
|
| - __ and_(r0, current_character(), Operand(mask));
|
| + __ land(r0, current_character(), Operand(mask));
|
| __ cmp(r0, Operand(c));
|
| }
|
| BranchOrBacktrack(ne, on_not_equal);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckNotCharacterAfterMinusAnd(
|
| +void RegExpMacroAssemblerSH4::CheckNotCharacterAfterMinusAnd(
|
| uc16 c,
|
| uc16 minus,
|
| uc16 mask,
|
| Label* on_not_equal) {
|
| ASSERT(minus < String::kMaxUtf16CodeUnit);
|
| __ sub(r0, current_character(), Operand(minus));
|
| - __ and_(r0, r0, Operand(mask));
|
| + __ land(r0, r0, Operand(mask));
|
| __ cmp(r0, Operand(c));
|
| BranchOrBacktrack(ne, on_not_equal);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckCharacterInRange(
|
| +void RegExpMacroAssemblerSH4::CheckCharacterInRange(
|
| uc16 from,
|
| uc16 to,
|
| Label* on_in_range) {
|
| __ sub(r0, current_character(), Operand(from));
|
| - __ cmp(r0, Operand(to - from));
|
| - BranchOrBacktrack(ls, on_in_range); // Unsigned lower-or-same condition.
|
| + __ cmphi(r0, Operand(to - from));
|
| + BranchOrBacktrack(ne, on_in_range); // Unsigned lower-or-same condition.
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckCharacterNotInRange(
|
| +void RegExpMacroAssemblerSH4::CheckCharacterNotInRange(
|
| uc16 from,
|
| uc16 to,
|
| Label* on_not_in_range) {
|
| __ sub(r0, current_character(), Operand(from));
|
| - __ cmp(r0, Operand(to - from));
|
| - BranchOrBacktrack(hi, on_not_in_range); // Unsigned higher condition.
|
| + __ cmphi(r0, Operand(to - from));
|
| + BranchOrBacktrack(eq, on_not_in_range); // Unsigned higher condition.
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckBitInTable(
|
| +void RegExpMacroAssemblerSH4::CheckBitInTable(
|
| Handle<ByteArray> table,
|
| Label* on_bit_set) {
|
| __ mov(r0, Operand(table));
|
| if (mode_ != ASCII || kTableMask != String::kMaxAsciiCharCode) {
|
| - __ and_(r1, current_character(), Operand(kTableSize - 1));
|
| + __ land(r1, current_character(), Operand(kTableSize - 1));
|
| __ add(r1, r1, Operand(ByteArray::kHeaderSize - kHeapObjectTag));
|
| } else {
|
| __ add(r1,
|
| @@ -517,12 +532,12 @@ void RegExpMacroAssemblerARM::CheckBitInTable(
|
| Operand(ByteArray::kHeaderSize - kHeapObjectTag));
|
| }
|
| __ ldrb(r0, MemOperand(r0, r1));
|
| - __ cmp(r0, Operand(0));
|
| + __ cmpeq(r0, Operand(0));
|
| BranchOrBacktrack(ne, on_bit_set);
|
| }
|
|
|
|
|
| -bool RegExpMacroAssemblerARM::CheckSpecialCharacterClass(uc16 type,
|
| +bool RegExpMacroAssemblerSH4::CheckSpecialCharacterClass(uc16 type,
|
| Label* on_no_match) {
|
| // Range checks (c in min..max) are generally implemented by an unsigned
|
| // (c - min) <= (max - min) check
|
| @@ -536,8 +551,8 @@ bool RegExpMacroAssemblerARM::CheckSpecialCharacterClass(uc16 type,
|
| __ b(eq, &success);
|
| // Check range 0x09..0x0d
|
| __ sub(r0, current_character(), Operand('\t'));
|
| - __ cmp(r0, Operand('\r' - '\t'));
|
| - BranchOrBacktrack(hi, on_no_match);
|
| + __ cmphi(r0, Operand('\r' - '\t'));
|
| + BranchOrBacktrack(eq, on_no_match);
|
| __ bind(&success);
|
| return true;
|
| }
|
| @@ -549,37 +564,37 @@ bool RegExpMacroAssemblerARM::CheckSpecialCharacterClass(uc16 type,
|
| __ cmp(current_character(), Operand(' '));
|
| BranchOrBacktrack(eq, on_no_match);
|
| __ sub(r0, current_character(), Operand('\t'));
|
| - __ cmp(r0, Operand('\r' - '\t'));
|
| - BranchOrBacktrack(ls, on_no_match);
|
| + __ cmphi(r0, Operand('\r' - '\t'));
|
| + BranchOrBacktrack(ne, on_no_match);
|
| return true;
|
| }
|
| return false;
|
| case 'd':
|
| // Match ASCII digits ('0'..'9')
|
| __ sub(r0, current_character(), Operand('0'));
|
| - __ cmp(current_character(), Operand('9' - '0'));
|
| - BranchOrBacktrack(hi, on_no_match);
|
| + __ cmphi(current_character(), Operand('9' - '0'));
|
| + BranchOrBacktrack(eq, on_no_match);
|
| return true;
|
| case 'D':
|
| // Match non ASCII-digits
|
| __ sub(r0, current_character(), Operand('0'));
|
| - __ cmp(r0, Operand('9' - '0'));
|
| - BranchOrBacktrack(ls, on_no_match);
|
| + __ cmphi(r0, Operand('9' - '0'));
|
| + BranchOrBacktrack(ne, on_no_match);
|
| return true;
|
| case '.': {
|
| // Match non-newlines (not 0x0a('\n'), 0x0d('\r'), 0x2028 and 0x2029)
|
| __ eor(r0, current_character(), Operand(0x01));
|
| // See if current character is '\n'^1 or '\r'^1, i.e., 0x0b or 0x0c
|
| __ sub(r0, r0, Operand(0x0b));
|
| - __ cmp(r0, Operand(0x0c - 0x0b));
|
| - BranchOrBacktrack(ls, on_no_match);
|
| + __ cmphi(r0, Operand(0x0c - 0x0b));
|
| + BranchOrBacktrack(ne, on_no_match);
|
| if (mode_ == UC16) {
|
| // Compare original value to 0x2028 and 0x2029, using the already
|
| // computed (current_char ^ 0x01 - 0x0b). I.e., check for
|
| // 0x201d (0x2028 - 0x0b) or 0x201e.
|
| __ sub(r0, r0, Operand(0x2028 - 0x0b));
|
| - __ cmp(r0, Operand(1));
|
| - BranchOrBacktrack(ls, on_no_match);
|
| + __ cmphi(r0, Operand(1));
|
| + BranchOrBacktrack(ne, on_no_match);
|
| }
|
| return true;
|
| }
|
| @@ -588,18 +603,18 @@ bool RegExpMacroAssemblerARM::CheckSpecialCharacterClass(uc16 type,
|
| __ eor(r0, current_character(), Operand(0x01));
|
| // See if current character is '\n'^1 or '\r'^1, i.e., 0x0b or 0x0c
|
| __ sub(r0, r0, Operand(0x0b));
|
| - __ cmp(r0, Operand(0x0c - 0x0b));
|
| + __ cmphi(r0, Operand(0x0c - 0x0b));
|
| if (mode_ == ASCII) {
|
| - BranchOrBacktrack(hi, on_no_match);
|
| + BranchOrBacktrack(eq, on_no_match);
|
| } else {
|
| Label done;
|
| - __ b(ls, &done);
|
| + __ b(ne, &done);
|
| // Compare original value to 0x2028 and 0x2029, using the already
|
| // computed (current_char ^ 0x01 - 0x0b). I.e., check for
|
| // 0x201d (0x2028 - 0x0b) or 0x201e.
|
| __ sub(r0, r0, Operand(0x2028 - 0x0b));
|
| - __ cmp(r0, Operand(1));
|
| - BranchOrBacktrack(hi, on_no_match);
|
| + __ cmphi(r0, Operand(1));
|
| + BranchOrBacktrack(eq, on_no_match);
|
| __ bind(&done);
|
| }
|
| return true;
|
| @@ -607,8 +622,8 @@ bool RegExpMacroAssemblerARM::CheckSpecialCharacterClass(uc16 type,
|
| case 'w': {
|
| if (mode_ != ASCII) {
|
| // Table is 128 entries, so all ASCII characters can be tested.
|
| - __ cmp(current_character(), Operand('z'));
|
| - BranchOrBacktrack(hi, on_no_match);
|
| + __ cmphi(current_character(), Operand('z'));
|
| + BranchOrBacktrack(eq, on_no_match);
|
| }
|
| ExternalReference map = ExternalReference::re_word_character_map();
|
| __ mov(r0, Operand(map));
|
| @@ -621,8 +636,8 @@ bool RegExpMacroAssemblerARM::CheckSpecialCharacterClass(uc16 type,
|
| Label done;
|
| if (mode_ != ASCII) {
|
| // Table is 128 entries, so all ASCII characters can be tested.
|
| - __ cmp(current_character(), Operand('z'));
|
| - __ b(hi, &done);
|
| + __ cmphi(current_character(), Operand('z'));
|
| + __ b(eq, &done);
|
| }
|
| ExternalReference map = ExternalReference::re_word_character_map();
|
| __ mov(r0, Operand(map));
|
| @@ -644,13 +659,13 @@ bool RegExpMacroAssemblerARM::CheckSpecialCharacterClass(uc16 type,
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::Fail() {
|
| +void RegExpMacroAssemblerSH4::Fail() {
|
| __ mov(r0, Operand(FAILURE));
|
| __ jmp(&exit_label_);
|
| }
|
|
|
|
|
| -Handle<HeapObject> RegExpMacroAssemblerARM::GetCode(Handle<String> source) {
|
| +Handle<HeapObject> RegExpMacroAssemblerSH4::GetCode(Handle<String> source) {
|
| Label return_r0;
|
| // Finalize code - write the entry point code now we know how many
|
| // registers we need.
|
| @@ -668,10 +683,13 @@ Handle<HeapObject> RegExpMacroAssemblerARM::GetCode(Handle<String> source) {
|
| // Start new stack frame.
|
| // Store link register in existing stack-cell.
|
| // Order here should correspond to order of offset constants in header file.
|
| - RegList registers_to_retain = r4.bit() | r5.bit() | r6.bit() |
|
| - r7.bit() | r8.bit() | r9.bit() | r10.bit() | fp.bit();
|
| - RegList argument_registers = r0.bit() | r1.bit() | r2.bit() | r3.bit();
|
| - __ stm(db_w, sp, argument_registers | registers_to_retain | lr.bit());
|
| + // WARNING: should change the value of kReturnAddress (depend on the number
|
| + // of saved registers.
|
| + RegList registers_to_retain = kCalleeSaved;
|
| + RegList argument_registers = r4.bit() | r5.bit() | r6.bit() | r7.bit();
|
| + __ push(pr);
|
| + __ pushm(registers_to_retain);
|
| + __ pushm(argument_registers);
|
| // Set frame pointer in space for it if this is not a direct call
|
| // from generated code.
|
| __ add(frame_pointer(), sp, Operand(4 * kPointerSize));
|
| @@ -686,13 +704,14 @@ Handle<HeapObject> RegExpMacroAssemblerARM::GetCode(Handle<String> source) {
|
| ExternalReference::address_of_stack_limit(masm_->isolate());
|
| __ mov(r0, Operand(stack_limit));
|
| __ ldr(r0, MemOperand(r0));
|
| - __ sub(r0, sp, r0, SetCC);
|
| // Handle it if the stack pointer is already below the stack limit.
|
| - __ b(ls, &stack_limit_hit);
|
| + __ cmphi(sp, r0);
|
| + __ sub(r0, sp, r0);
|
| + __ b(ne, &stack_limit_hit);
|
| // Check if there is room for the variable number of registers above
|
| // the stack limit.
|
| - __ cmp(r0, Operand(num_registers_ * kPointerSize));
|
| - __ b(hs, &stack_ok);
|
| + __ cmphs(r0, Operand(num_registers_ * kPointerSize));
|
| + __ b(eq, &stack_ok, Label::kNear);
|
| // Exit with OutOfMemory exception. There is not enough space on the stack
|
| // for our working registers.
|
| __ mov(r0, Operand(EXCEPTION));
|
| @@ -718,7 +737,8 @@ Handle<HeapObject> RegExpMacroAssemblerARM::GetCode(Handle<String> source) {
|
| // (effectively string position -1).
|
| __ ldr(r1, MemOperand(frame_pointer(), kStartIndex));
|
| __ sub(r0, current_input_offset(), Operand(char_size()));
|
| - __ sub(r0, r0, Operand(r1, LSL, (mode_ == UC16) ? 1 : 0));
|
| + __ lsl(ip, r1, Operand((mode_ == UC16) ? 1 : 0));
|
| + __ sub(r0, r0, ip);
|
| // Store this value in a local variable, for use when clearing
|
| // position registers.
|
| __ str(r0, MemOperand(frame_pointer(), kInputStartMinusOne));
|
| @@ -730,7 +750,7 @@ Handle<HeapObject> RegExpMacroAssemblerARM::GetCode(Handle<String> source) {
|
| // Load newline if index is at start, previous character otherwise.
|
| __ cmp(r1, Operand(0, RelocInfo::NONE));
|
| __ b(ne, &load_char_start_regexp);
|
| - __ mov(current_character(), Operand('\n'), LeaveCC, eq);
|
| + __ mov(current_character(), Operand('\n'), eq);
|
| __ jmp(&start_regexp);
|
|
|
| // Global regexp restarts matching here.
|
| @@ -748,8 +768,9 @@ Handle<HeapObject> RegExpMacroAssemblerARM::GetCode(Handle<String> source) {
|
| __ mov(r2, Operand(num_saved_registers_));
|
| Label init_loop;
|
| __ bind(&init_loop);
|
| - __ str(r0, MemOperand(r1, kPointerSize, NegPostIndex));
|
| - __ sub(r2, r2, Operand(1), SetCC);
|
| + __ str(r0, MemOperand(r1, kPointerSize));
|
| + __ add(r1, r1, Operand(-kPointerSize));
|
| + __ dt(r2);
|
| __ b(ne, &init_loop);
|
| } else {
|
| for (int i = 0; i < num_saved_registers_; i++) {
|
| @@ -775,10 +796,10 @@ Handle<HeapObject> RegExpMacroAssemblerARM::GetCode(Handle<String> source) {
|
| __ sub(r1, end_of_input_address(), r1);
|
| // r1 is length of input in bytes.
|
| if (mode_ == UC16) {
|
| - __ mov(r1, Operand(r1, LSR, 1));
|
| + __ lsr(r1, r1, Operand(1));
|
| }
|
| // r1 is length of input in characters.
|
| - __ add(r1, r1, Operand(r2));
|
| + __ add(r1, r1, r2);
|
| // r1 is length of string in characters.
|
|
|
| ASSERT_EQ(0, num_saved_registers_ % 2);
|
| @@ -793,11 +814,13 @@ Handle<HeapObject> RegExpMacroAssemblerARM::GetCode(Handle<String> source) {
|
| __ mov(r4, r2);
|
| }
|
| if (mode_ == UC16) {
|
| - __ add(r2, r1, Operand(r2, ASR, 1));
|
| - __ add(r3, r1, Operand(r3, ASR, 1));
|
| + __ asr(r2, r2, Operand(1));
|
| + __ add(r2, r1, r2);
|
| + __ asr(r3, r3, Operand(1));
|
| + __ add(r3, r1, r3);
|
| } else {
|
| - __ add(r2, r1, Operand(r2));
|
| - __ add(r3, r1, Operand(r3));
|
| + __ add(r2, r1, r2);
|
| + __ add(r3, r1, r3);
|
| }
|
| __ str(r2, MemOperand(r0, kPointerSize, PostIndex));
|
| __ str(r3, MemOperand(r0, kPointerSize, PostIndex));
|
| @@ -816,8 +839,8 @@ Handle<HeapObject> RegExpMacroAssemblerARM::GetCode(Handle<String> source) {
|
| // output registers is reduced by the number of stored captures.
|
| __ sub(r1, r1, Operand(num_saved_registers_));
|
| // Check whether we have enough room for another set of capture results.
|
| - __ cmp(r1, Operand(num_saved_registers_));
|
| - __ b(lt, &return_r0);
|
| + __ cmpge(r1, Operand(num_saved_registers_));
|
| + __ bf(&return_r0);
|
|
|
| __ str(r1, MemOperand(frame_pointer(), kNumOutputRegisters));
|
| // Advance the location for output.
|
| @@ -858,7 +881,9 @@ Handle<HeapObject> RegExpMacroAssemblerARM::GetCode(Handle<String> source) {
|
| // Skip sp past regexp registers and local variables..
|
| __ mov(sp, frame_pointer());
|
| // Restore registers r4..r11 and return (restoring lr to pc).
|
| - __ ldm(ia_w, sp, registers_to_retain | pc.bit());
|
| + __ popm(registers_to_retain);
|
| + __ pop(pr);
|
| + __ rts();
|
|
|
| // Backtrack code (branch target for conditional backtracks).
|
| if (backtrack_label_.is_linked()) {
|
| @@ -890,16 +915,18 @@ Handle<HeapObject> RegExpMacroAssemblerARM::GetCode(Handle<String> source) {
|
| Label grow_failed;
|
|
|
| // Call GrowStack(backtrack_stackpointer(), &stack_base)
|
| + __ Push(r4, r5, r6, r7);
|
| static const int num_arguments = 3;
|
| + __ mov(r4, backtrack_stackpointer());
|
| + __ add(r5, frame_pointer(), Operand(kStackHighEnd));
|
| + __ mov(r6, Operand(ExternalReference::isolate_address()));
|
| __ PrepareCallCFunction(num_arguments, r0);
|
| - __ mov(r0, backtrack_stackpointer());
|
| - __ add(r1, frame_pointer(), Operand(kStackHighEnd));
|
| - __ mov(r2, Operand(ExternalReference::isolate_address()));
|
| ExternalReference grow_stack =
|
| ExternalReference::re_grow_stack(masm_->isolate());
|
| __ CallCFunction(grow_stack, num_arguments);
|
| // If return NULL, we have failed to grow the stack, and
|
| // must exit with a stack-overflow exception.
|
| + __ Pop(r4, r5, r6, r7);
|
| __ cmp(r0, Operand(0, RelocInfo::NONE));
|
| __ b(eq, &exit_with_exception);
|
| // Otherwise use return value as new stack pointer.
|
| @@ -926,44 +953,44 @@ Handle<HeapObject> RegExpMacroAssemblerARM::GetCode(Handle<String> source) {
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::GoTo(Label* to) {
|
| +void RegExpMacroAssemblerSH4::GoTo(Label* to) {
|
| BranchOrBacktrack(al, to);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::IfRegisterGE(int reg,
|
| +void RegExpMacroAssemblerSH4::IfRegisterGE(int reg,
|
| int comparand,
|
| Label* if_ge) {
|
| __ ldr(r0, register_location(reg));
|
| - __ cmp(r0, Operand(comparand));
|
| - BranchOrBacktrack(ge, if_ge);
|
| + __ cmpge(r0, Operand(comparand));
|
| + BranchOrBacktrack(eq, if_ge);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::IfRegisterLT(int reg,
|
| +void RegExpMacroAssemblerSH4::IfRegisterLT(int reg,
|
| int comparand,
|
| Label* if_lt) {
|
| __ ldr(r0, register_location(reg));
|
| - __ cmp(r0, Operand(comparand));
|
| - BranchOrBacktrack(lt, if_lt);
|
| + __ cmpge(r0, Operand(comparand));
|
| + BranchOrBacktrack(ne, if_lt);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::IfRegisterEqPos(int reg,
|
| +void RegExpMacroAssemblerSH4::IfRegisterEqPos(int reg,
|
| Label* if_eq) {
|
| __ ldr(r0, register_location(reg));
|
| - __ cmp(r0, Operand(current_input_offset()));
|
| + __ cmp(r0, current_input_offset());
|
| BranchOrBacktrack(eq, if_eq);
|
| }
|
|
|
|
|
| RegExpMacroAssembler::IrregexpImplementation
|
| - RegExpMacroAssemblerARM::Implementation() {
|
| - return kARMImplementation;
|
| + RegExpMacroAssemblerSH4::Implementation() {
|
| + return kSH4Implementation;
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::LoadCurrentCharacter(int cp_offset,
|
| +void RegExpMacroAssemblerSH4::LoadCurrentCharacter(int cp_offset,
|
| Label* on_end_of_input,
|
| bool check_bounds,
|
| int characters) {
|
| @@ -976,59 +1003,35 @@ void RegExpMacroAssemblerARM::LoadCurrentCharacter(int cp_offset,
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::PopCurrentPosition() {
|
| +void RegExpMacroAssemblerSH4::PopCurrentPosition() {
|
| Pop(current_input_offset());
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::PopRegister(int register_index) {
|
| +void RegExpMacroAssemblerSH4::PopRegister(int register_index) {
|
| Pop(r0);
|
| __ str(r0, register_location(register_index));
|
| }
|
|
|
|
|
| -static bool is_valid_memory_offset(int value) {
|
| - if (value < 0) value = -value;
|
| - return value < (1<<12);
|
| -}
|
| -
|
| -
|
| -void RegExpMacroAssemblerARM::PushBacktrack(Label* label) {
|
| +void RegExpMacroAssemblerSH4::PushBacktrack(Label* label) {
|
| if (label->is_bound()) {
|
| int target = label->pos();
|
| __ mov(r0, Operand(target + Code::kHeaderSize - kHeapObjectTag));
|
| } else {
|
| - int constant_offset = GetBacktrackConstantPoolEntry();
|
| - masm_->label_at_put(label, constant_offset);
|
| - // Reading pc-relative is based on the address 8 bytes ahead of
|
| - // the current opcode.
|
| - unsigned int offset_of_pc_register_read =
|
| - masm_->pc_offset() + Assembler::kPcLoadDelta;
|
| - int pc_offset_of_constant =
|
| - constant_offset - offset_of_pc_register_read;
|
| - ASSERT(pc_offset_of_constant < 0);
|
| - if (is_valid_memory_offset(pc_offset_of_constant)) {
|
| - Assembler::BlockConstPoolScope block_const_pool(masm_);
|
| - __ ldr(r0, MemOperand(pc, pc_offset_of_constant));
|
| - } else {
|
| - // Not a 12-bit offset, so it needs to be loaded from the constant
|
| - // pool.
|
| - Assembler::BlockConstPoolScope block_const_pool(masm_);
|
| - __ mov(r0, Operand(pc_offset_of_constant + Assembler::kInstrSize));
|
| - __ ldr(r0, MemOperand(pc, r0));
|
| - }
|
| + masm_->load_label(label);
|
| }
|
| Push(r0);
|
| CheckStackLimit();
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::PushCurrentPosition() {
|
| +void RegExpMacroAssemblerSH4::PushCurrentPosition() {
|
| Push(current_input_offset());
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::PushRegister(int register_index,
|
| +void RegExpMacroAssemblerSH4::PushRegister(int register_index,
|
| StackCheckFlag check_stack_limit) {
|
| __ ldr(r0, register_location(register_index));
|
| Push(r0);
|
| @@ -1036,22 +1039,22 @@ void RegExpMacroAssemblerARM::PushRegister(int register_index,
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::ReadCurrentPositionFromRegister(int reg) {
|
| +void RegExpMacroAssemblerSH4::ReadCurrentPositionFromRegister(int reg) {
|
| __ ldr(current_input_offset(), register_location(reg));
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::ReadStackPointerFromRegister(int reg) {
|
| +void RegExpMacroAssemblerSH4::ReadStackPointerFromRegister(int reg) {
|
| __ ldr(backtrack_stackpointer(), register_location(reg));
|
| __ ldr(r0, MemOperand(frame_pointer(), kStackHighEnd));
|
| - __ add(backtrack_stackpointer(), backtrack_stackpointer(), Operand(r0));
|
| + __ add(backtrack_stackpointer(), backtrack_stackpointer(), r0);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::SetCurrentPositionFromEnd(int by) {
|
| +void RegExpMacroAssemblerSH4::SetCurrentPositionFromEnd(int by) {
|
| Label after_position;
|
| - __ cmp(current_input_offset(), Operand(-by * char_size()));
|
| - __ b(ge, &after_position);
|
| + __ cmpge(current_input_offset(), Operand(-by * char_size()));
|
| + __ b(eq, &after_position);
|
| __ mov(current_input_offset(), Operand(-by * char_size()));
|
| // On RegExp code entry (where this operation is used), the character before
|
| // the current position is expected to be already loaded.
|
| @@ -1061,20 +1064,20 @@ void RegExpMacroAssemblerARM::SetCurrentPositionFromEnd(int by) {
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::SetRegister(int register_index, int to) {
|
| +void RegExpMacroAssemblerSH4::SetRegister(int register_index, int to) {
|
| ASSERT(register_index >= num_saved_registers_); // Reserved for positions!
|
| __ mov(r0, Operand(to));
|
| __ str(r0, register_location(register_index));
|
| }
|
|
|
|
|
| -bool RegExpMacroAssemblerARM::Succeed() {
|
| +bool RegExpMacroAssemblerSH4::Succeed() {
|
| __ jmp(&success_label_);
|
| return global();
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::WriteCurrentPositionToRegister(int reg,
|
| +void RegExpMacroAssemblerSH4::WriteCurrentPositionToRegister(int reg,
|
| int cp_offset) {
|
| if (cp_offset == 0) {
|
| __ str(current_input_offset(), register_location(reg));
|
| @@ -1085,7 +1088,7 @@ void RegExpMacroAssemblerARM::WriteCurrentPositionToRegister(int reg,
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::ClearRegisters(int reg_from, int reg_to) {
|
| +void RegExpMacroAssemblerSH4::ClearRegisters(int reg_from, int reg_to) {
|
| ASSERT(reg_from <= reg_to);
|
| __ ldr(r0, MemOperand(frame_pointer(), kInputStartMinusOne));
|
| for (int reg = reg_from; reg <= reg_to; reg++) {
|
| @@ -1094,7 +1097,7 @@ void RegExpMacroAssemblerARM::ClearRegisters(int reg_from, int reg_to) {
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::WriteStackPointerToRegister(int reg) {
|
| +void RegExpMacroAssemblerSH4::WriteStackPointerToRegister(int reg) {
|
| __ ldr(r1, MemOperand(frame_pointer(), kStackHighEnd));
|
| __ sub(r0, backtrack_stackpointer(), r1);
|
| __ str(r0, register_location(reg));
|
| @@ -1103,17 +1106,21 @@ void RegExpMacroAssemblerARM::WriteStackPointerToRegister(int reg) {
|
|
|
| // Private methods:
|
|
|
| -void RegExpMacroAssemblerARM::CallCheckStackGuardState(Register scratch) {
|
| +void RegExpMacroAssemblerSH4::CallCheckStackGuardState(Register scratch) {
|
| static const int num_arguments = 3;
|
| + // We do not have to save r5 as this value is then putted back by
|
| + // CallCFunctionUsingStub (from the CodeObject)
|
| + __ Push(r4, r6, r7);
|
| __ PrepareCallCFunction(num_arguments, scratch);
|
| // RegExp code frame pointer.
|
| - __ mov(r2, frame_pointer());
|
| + __ mov(r6, frame_pointer());
|
| // Code* of self.
|
| - __ mov(r1, Operand(masm_->CodeObject()));
|
| + __ mov(r5, Operand(masm_->CodeObject()));
|
| // r0 becomes return address pointer.
|
| ExternalReference stack_guard_check =
|
| ExternalReference::re_check_stack_guard_state(masm_->isolate());
|
| CallCFunctionUsingStub(stack_guard_check, num_arguments);
|
| + __ Pop(r4, r6, r7);
|
| }
|
|
|
|
|
| @@ -1124,7 +1131,7 @@ static T& frame_entry(Address re_frame, int frame_offset) {
|
| }
|
|
|
|
|
| -int RegExpMacroAssemblerARM::CheckStackGuardState(Address* return_address,
|
| +int RegExpMacroAssemblerSH4::CheckStackGuardState(Address* return_address,
|
| Code* re_code,
|
| Address re_frame) {
|
| Isolate* isolate = frame_entry<Isolate*>(re_frame, kIsolate);
|
| @@ -1223,7 +1230,7 @@ int RegExpMacroAssemblerARM::CheckStackGuardState(Address* return_address,
|
| }
|
|
|
|
|
| -MemOperand RegExpMacroAssemblerARM::register_location(int register_index) {
|
| +MemOperand RegExpMacroAssemblerSH4::register_location(int register_index) {
|
| ASSERT(register_index < (1<<30));
|
| if (num_registers_ <= register_index) {
|
| num_registers_ = register_index + 1;
|
| @@ -1233,14 +1240,14 @@ MemOperand RegExpMacroAssemblerARM::register_location(int register_index) {
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckPosition(int cp_offset,
|
| +void RegExpMacroAssemblerSH4::CheckPosition(int cp_offset,
|
| Label* on_outside_input) {
|
| - __ cmp(current_input_offset(), Operand(-cp_offset * char_size()));
|
| - BranchOrBacktrack(ge, on_outside_input);
|
| + __ cmpge(current_input_offset(), Operand(-cp_offset * char_size()));
|
| + BranchOrBacktrack(eq, on_outside_input);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::BranchOrBacktrack(Condition condition,
|
| +void RegExpMacroAssemblerSH4::BranchOrBacktrack(Condition condition,
|
| Label* to) {
|
| if (condition == al) { // Unconditional.
|
| if (to == NULL) {
|
| @@ -1258,112 +1265,81 @@ void RegExpMacroAssemblerARM::BranchOrBacktrack(Condition condition,
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::SafeCall(Label* to, Condition cond) {
|
| - __ bl(to, cond);
|
| +void RegExpMacroAssemblerSH4::SafeCall(Label* to, Condition cond) {
|
| + Label skip;
|
| + ASSERT(cond == eq || cond == ne);
|
| + __ b(NegateCondition(cond), &skip, Label::kNear);
|
| + __ jsr(to);
|
| + __ bind(&skip);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::SafeReturn() {
|
| - __ pop(lr);
|
| - __ add(pc, lr, Operand(masm_->CodeObject()));
|
| +void RegExpMacroAssemblerSH4::SafeReturn() {
|
| + __ pop(ip);
|
| + __ add(ip, ip, Operand(masm_->CodeObject()));
|
| + __ mov(pr, ip);
|
| + __ rts();
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::SafeCallTarget(Label* name) {
|
| +void RegExpMacroAssemblerSH4::SafeCallTarget(Label* name) {
|
| __ bind(name);
|
| - __ sub(lr, lr, Operand(masm_->CodeObject()));
|
| + __ mov(ip, pr);
|
| + __ sub(ip, ip, Operand(masm_->CodeObject()));
|
| + __ mov(pr, ip);
|
| __ push(lr);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::Push(Register source) {
|
| +void RegExpMacroAssemblerSH4::Push(Register source) {
|
| ASSERT(!source.is(backtrack_stackpointer()));
|
| - __ str(source,
|
| - MemOperand(backtrack_stackpointer(), kPointerSize, NegPreIndex));
|
| + __ add(backtrack_stackpointer(), backtrack_stackpointer(),
|
| + Operand(-kPointerSize));
|
| + __ str(source, MemOperand(backtrack_stackpointer()));
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::Pop(Register target) {
|
| +void RegExpMacroAssemblerSH4::Pop(Register target) {
|
| ASSERT(!target.is(backtrack_stackpointer()));
|
| __ ldr(target,
|
| MemOperand(backtrack_stackpointer(), kPointerSize, PostIndex));
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckPreemption() {
|
| +void RegExpMacroAssemblerSH4::CheckPreemption() {
|
| // Check for preemption.
|
| ExternalReference stack_limit =
|
| ExternalReference::address_of_stack_limit(masm_->isolate());
|
| __ mov(r0, Operand(stack_limit));
|
| __ ldr(r0, MemOperand(r0));
|
| - __ cmp(sp, r0);
|
| - SafeCall(&check_preempt_label_, ls);
|
| + __ cmphi(sp, r0);
|
| + SafeCall(&check_preempt_label_, ne);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::CheckStackLimit() {
|
| +void RegExpMacroAssemblerSH4::CheckStackLimit() {
|
| ExternalReference stack_limit =
|
| ExternalReference::address_of_regexp_stack_limit(masm_->isolate());
|
| __ mov(r0, Operand(stack_limit));
|
| __ ldr(r0, MemOperand(r0));
|
| - __ cmp(backtrack_stackpointer(), Operand(r0));
|
| - SafeCall(&stack_overflow_label_, ls);
|
| + __ cmphi(backtrack_stackpointer(), r0);
|
| + SafeCall(&stack_overflow_label_, ne);
|
| }
|
|
|
|
|
| -void RegExpMacroAssemblerARM::EmitBacktrackConstantPool() {
|
| - __ CheckConstPool(false, false);
|
| - Assembler::BlockConstPoolScope block_const_pool(masm_);
|
| - backtrack_constant_pool_offset_ = masm_->pc_offset();
|
| - for (int i = 0; i < kBacktrackConstantPoolSize; i++) {
|
| - __ emit(0);
|
| - }
|
| -
|
| - backtrack_constant_pool_capacity_ = kBacktrackConstantPoolSize;
|
| -}
|
| -
|
| -
|
| -int RegExpMacroAssemblerARM::GetBacktrackConstantPoolEntry() {
|
| - while (backtrack_constant_pool_capacity_ > 0) {
|
| - int offset = backtrack_constant_pool_offset_;
|
| - backtrack_constant_pool_offset_ += kPointerSize;
|
| - backtrack_constant_pool_capacity_--;
|
| - if (masm_->pc_offset() - offset < 2 * KB) {
|
| - return offset;
|
| - }
|
| - }
|
| - Label new_pool_skip;
|
| - __ jmp(&new_pool_skip);
|
| - EmitBacktrackConstantPool();
|
| - __ bind(&new_pool_skip);
|
| - int offset = backtrack_constant_pool_offset_;
|
| - backtrack_constant_pool_offset_ += kPointerSize;
|
| - backtrack_constant_pool_capacity_--;
|
| - return offset;
|
| -}
|
| -
|
| -
|
| -void RegExpMacroAssemblerARM::CallCFunctionUsingStub(
|
| +void RegExpMacroAssemblerSH4::CallCFunctionUsingStub(
|
| ExternalReference function,
|
| int num_arguments) {
|
| // Must pass all arguments in registers. The stub pushes on the stack.
|
| ASSERT(num_arguments <= 4);
|
| - __ mov(code_pointer(), Operand(function));
|
| + __ mov(r1, Operand(function));
|
| RegExpCEntryStub stub;
|
| __ CallStub(&stub);
|
| - if (OS::ActivationFrameAlignment() != 0) {
|
| - __ ldr(sp, MemOperand(sp, 0));
|
| - }
|
| __ mov(code_pointer(), Operand(masm_->CodeObject()));
|
| }
|
|
|
|
|
| -bool RegExpMacroAssemblerARM::CanReadUnaligned() {
|
| - return CpuFeatures::IsSupported(UNALIGNED_ACCESSES) && !slow_safe();
|
| -}
|
| -
|
| -
|
| -void RegExpMacroAssemblerARM::LoadCurrentCharacterUnchecked(int cp_offset,
|
| +void RegExpMacroAssemblerSH4::LoadCurrentCharacterUnchecked(int cp_offset,
|
| int characters) {
|
| Register offset = current_input_offset();
|
| if (cp_offset != 0) {
|
| @@ -1375,9 +1351,9 @@ void RegExpMacroAssemblerARM::LoadCurrentCharacterUnchecked(int cp_offset,
|
| // and the operating system running on the target allow it.
|
| // If unaligned load/stores are not supported then this function must only
|
| // be used to load a single character at a time.
|
| - if (!CanReadUnaligned()) {
|
| - ASSERT(characters == 1);
|
| - }
|
| +#if !V8_TARGET_CAN_READ_UNALIGNED
|
| + ASSERT(characters == 1);
|
| +#endif
|
|
|
| if (mode_ == ASCII) {
|
| if (characters == 4) {
|
| @@ -1401,14 +1377,17 @@ void RegExpMacroAssemblerARM::LoadCurrentCharacterUnchecked(int cp_offset,
|
|
|
|
|
| void RegExpCEntryStub::Generate(MacroAssembler* masm_) {
|
| - int stack_alignment = OS::ActivationFrameAlignment();
|
| - if (stack_alignment < kPointerSize) stack_alignment = kPointerSize;
|
| - // Stack is already aligned for call, so decrement by alignment
|
| - // to make room for storing the link register.
|
| - __ str(lr, MemOperand(sp, stack_alignment, NegPreIndex));
|
| - __ mov(r0, sp);
|
| - __ Call(r5);
|
| - __ ldr(pc, MemOperand(sp, stack_alignment, PostIndex));
|
| + // TODO(STM): do we have to align the stack arguments ?
|
| + // // Decrement it by kPointerSize to make room for pushing and poping pr
|
| + // int stack_alignment = OS::ActivationFrameAlignment() - kPointerSize;
|
| + // // Stack is already aligned for call, so decrement by alignment
|
| + // // to make room for storing the link register.
|
| + __ push(pr);
|
| + // The first argument should be sp
|
| + __ mov(r4, sp);
|
| + __ jsr(r1);
|
| + __ pop(pr);
|
| + __ rts();
|
| }
|
|
|
| #undef __
|
| @@ -1417,4 +1396,4 @@ void RegExpCEntryStub::Generate(MacroAssembler* masm_) {
|
|
|
| }} // namespace v8::internal
|
|
|
| -#endif // V8_TARGET_ARCH_ARM
|
| +#endif // V8_TARGET_ARCH_SH4
|
|
|
Chromium Code Reviews
