1 // Copyright 2012 the V8 project authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "src/v8.h" 6 7 #if V8_TARGET_ARCH_MIPS64 8 9 #include "src/code-stubs.h" 10 #include "src/log.h" 11 #include "src/macro-assembler.h" 12 #include "src/regexp-macro-assembler.h" 13 #include "src/regexp-stack.h" 14 #include "src/unicode.h" 15 16 #include "src/mips64/regexp-macro-assembler-mips64.h" 17 18 namespace v8 { 19 namespace internal { 20 21 #ifndef V8_INTERPRETED_REGEXP 22 /* 23 * This assembler uses the following register assignment convention 24 * - t3 : Temporarily stores the index of capture start after a matching pass 25 * for a global regexp. 26 * - a5 : Pointer to current code object (Code*) including heap object tag. 27 * - a6 : Current position in input, as negative offset from end of string. 28 * Please notice that this is the byte offset, not the character offset! 29 * - a7 : Currently loaded character. Must be loaded using 30 * LoadCurrentCharacter before using any of the dispatch methods. 31 * - t0 : Points to tip of backtrack stack 32 * - t1 : Unused. 33 * - t2 : End of input (points to byte after last character in input). 34 * - fp : Frame pointer. Used to access arguments, local variables and 35 * RegExp registers. 36 * - sp : Points to tip of C stack. 37 * 38 * The remaining registers are free for computations. 39 * Each call to a public method should retain this convention. 40 * 41 * TODO(plind): O32 documented here with intent of having single 32/64 codebase 42 * in the future. 43 * 44 * The O32 stack will have the following structure: 45 * 46 * - fp[76] Isolate* isolate (address of the current isolate) 47 * - fp[72] direct_call (if 1, direct call from JavaScript code, 48 * if 0, call through the runtime system). 49 * - fp[68] stack_area_base (High end of the memory area to use as 50 * backtracking stack). 51 * - fp[64] capture array size (may fit multiple sets of matches) 52 * - fp[60] int* capture_array (int[num_saved_registers_], for output). 53 * - fp[44..59] MIPS O32 four argument slots 54 * - fp[40] secondary link/return address used by native call. 55 * --- sp when called --- 56 * - fp[36] return address (lr). 57 * - fp[32] old frame pointer (r11). 58 * - fp[0..31] backup of registers s0..s7. 59 * --- frame pointer ---- 60 * - fp[-4] end of input (address of end of string). 61 * - fp[-8] start of input (address of first character in string). 62 * - fp[-12] start index (character index of start). 63 * - fp[-16] void* input_string (location of a handle containing the string). 64 * - fp[-20] success counter (only for global regexps to count matches). 65 * - fp[-24] Offset of location before start of input (effectively character 66 * position -1). Used to initialize capture registers to a 67 * non-position. 68 * - fp[-28] At start (if 1, we are starting at the start of the 69 * string, otherwise 0) 70 * - fp[-32] register 0 (Only positions must be stored in the first 71 * - register 1 num_saved_registers_ registers) 72 * - ... 73 * - register num_registers-1 74 * --- sp --- 75 * 76 * 77 * The N64 stack will have the following structure: 78 * 79 * - fp[88] Isolate* isolate (address of the current isolate) kIsolate 80 * - fp[80] secondary link/return address used by exit frame on native call. kSecondaryReturnAddress 81 kStackFrameHeader 82 * --- sp when called --- 83 * - fp[72] ra Return from RegExp code (ra). kReturnAddress 84 * - fp[64] s9, old-fp Old fp, callee saved(s9). 85 * - fp[0..63] s0..s7 Callee-saved registers s0..s7. 86 * --- frame pointer ---- 87 * - fp[-8] direct_call (1 = direct call from JS, 0 = from runtime) kDirectCall 88 * - fp[-16] stack_base (Top of backtracking stack). kStackHighEnd 89 * - fp[-24] capture array size (may fit multiple sets of matches) kNumOutputRegisters 90 * - fp[-32] int* capture_array (int[num_saved_registers_], for output). kRegisterOutput 91 * - fp[-40] end of input (address of end of string). kInputEnd 92 * - fp[-48] start of input (address of first character in string). kInputStart 93 * - fp[-56] start index (character index of start). kStartIndex 94 * - fp[-64] void* input_string (location of a handle containing the string). kInputString 95 * - fp[-72] success counter (only for global regexps to count matches). kSuccessfulCaptures 96 * - fp[-80] Offset of location before start of input (effectively character kInputStartMinusOne 97 * position -1). Used to initialize capture registers to a 98 * non-position. 99 * --------- The following output registers are 32-bit values. --------- 100 * - fp[-88] register 0 (Only positions must be stored in the first kRegisterZero 101 * - register 1 num_saved_registers_ registers) 102 * - ... 103 * - register num_registers-1 104 * --- sp --- 105 * 106 * The first num_saved_registers_ registers are initialized to point to 107 * "character -1" in the string (i.e., char_size() bytes before the first 108 * character of the string). The remaining registers start out as garbage. 109 * 110 * The data up to the return address must be placed there by the calling 111 * code and the remaining arguments are passed in registers, e.g. by calling the 112 * code entry as cast to a function with the signature: 113 * int (*match)(String* input_string, 114 * int start_index, 115 * Address start, 116 * Address end, 117 * Address secondary_return_address, // Only used by native call. 118 * int* capture_output_array, 119 * byte* stack_area_base, 120 * bool direct_call = false, 121 * void* return_address, 122 * Isolate* isolate); 123 * The call is performed by NativeRegExpMacroAssembler::Execute() 124 * (in regexp-macro-assembler.cc) via the CALL_GENERATED_REGEXP_CODE macro 125 * in mips/simulator-mips.h. 126 * When calling as a non-direct call (i.e., from C++ code), the return address 127 * area is overwritten with the ra register by the RegExp code. When doing a 128 * direct call from generated code, the return address is placed there by 129 * the calling code, as in a normal exit frame. 130 */ 131 132 #define __ ACCESS_MASM(masm_) 133 134 RegExpMacroAssemblerMIPS::RegExpMacroAssemblerMIPS( 135 Mode mode, 136 int registers_to_save, 137 Zone* zone) 138 : NativeRegExpMacroAssembler(zone), 139 masm_(new MacroAssembler(zone->isolate(), NULL, kRegExpCodeSize)), 140 mode_(mode), 141 num_registers_(registers_to_save), 142 num_saved_registers_(registers_to_save), 143 entry_label_(), 144 start_label_(), 145 success_label_(), 146 backtrack_label_(), 147 exit_label_(), 148 internal_failure_label_() { 149 DCHECK_EQ(0, registers_to_save % 2); 150 __ jmp(&entry_label_); // We'll write the entry code later. 151 // If the code gets too big or corrupted, an internal exception will be 152 // raised, and we will exit right away. 153 __ bind(&internal_failure_label_); 154 __ li(v0, Operand(FAILURE)); 155 __ Ret(); 156 __ bind(&start_label_); // And then continue from here. 157 } 158 159 160 RegExpMacroAssemblerMIPS::~RegExpMacroAssemblerMIPS() { 161 delete masm_; 162 // Unuse labels in case we throw away the assembler without calling GetCode. 163 entry_label_.Unuse(); 164 start_label_.Unuse(); 165 success_label_.Unuse(); 166 backtrack_label_.Unuse(); 167 exit_label_.Unuse(); 168 check_preempt_label_.Unuse(); 169 stack_overflow_label_.Unuse(); 170 internal_failure_label_.Unuse(); 171 } 172 173 174 int RegExpMacroAssemblerMIPS::stack_limit_slack() { 175 return RegExpStack::kStackLimitSlack; 176 } 177 178 179 void RegExpMacroAssemblerMIPS::AdvanceCurrentPosition(int by) { 180 if (by != 0) { 181 __ Daddu(current_input_offset(), 182 current_input_offset(), Operand(by * char_size())); 183 } 184 } 185 186 187 void RegExpMacroAssemblerMIPS::AdvanceRegister(int reg, int by) { 188 DCHECK(reg >= 0); 189 DCHECK(reg < num_registers_); 190 if (by != 0) { 191 __ ld(a0, register_location(reg)); 192 __ Daddu(a0, a0, Operand(by)); 193 __ sd(a0, register_location(reg)); 194 } 195 } 196 197 198 void RegExpMacroAssemblerMIPS::Backtrack() { 199 CheckPreemption(); 200 // Pop Code* offset from backtrack stack, add Code* and jump to location. 201 Pop(a0); 202 __ Daddu(a0, a0, code_pointer()); 203 __ Jump(a0); 204 } 205 206 207 void RegExpMacroAssemblerMIPS::Bind(Label* label) { 208 __ bind(label); 209 } 210 211 212 void RegExpMacroAssemblerMIPS::CheckCharacter(uint32_t c, Label* on_equal) { 213 BranchOrBacktrack(on_equal, eq, current_character(), Operand(c)); 214 } 215 216 217 void RegExpMacroAssemblerMIPS::CheckCharacterGT(uc16 limit, Label* on_greater) { 218 BranchOrBacktrack(on_greater, gt, current_character(), Operand(limit)); 219 } 220 221 222 void RegExpMacroAssemblerMIPS::CheckAtStart(Label* on_at_start) { 223 Label not_at_start; 224 // Did we start the match at the start of the string at all? 225 __ lw(a0, MemOperand(frame_pointer(), kStartIndex)); 226 BranchOrBacktrack(¬_at_start, ne, a0, Operand(zero_reg)); 227 228 // If we did, are we still at the start of the input? 229 __ ld(a1, MemOperand(frame_pointer(), kInputStart)); 230 __ Daddu(a0, end_of_input_address(), Operand(current_input_offset())); 231 BranchOrBacktrack(on_at_start, eq, a0, Operand(a1)); 232 __ bind(¬_at_start); 233 } 234 235 236 void RegExpMacroAssemblerMIPS::CheckNotAtStart(Label* on_not_at_start) { 237 // Did we start the match at the start of the string at all? 238 __ lw(a0, MemOperand(frame_pointer(), kStartIndex)); 239 BranchOrBacktrack(on_not_at_start, ne, a0, Operand(zero_reg)); 240 // If we did, are we still at the start of the input? 241 __ ld(a1, MemOperand(frame_pointer(), kInputStart)); 242 __ Daddu(a0, end_of_input_address(), Operand(current_input_offset())); 243 BranchOrBacktrack(on_not_at_start, ne, a0, Operand(a1)); 244 } 245 246 247 void RegExpMacroAssemblerMIPS::CheckCharacterLT(uc16 limit, Label* on_less) { 248 BranchOrBacktrack(on_less, lt, current_character(), Operand(limit)); 249 } 250 251 252 void RegExpMacroAssemblerMIPS::CheckGreedyLoop(Label* on_equal) { 253 Label backtrack_non_equal; 254 __ lw(a0, MemOperand(backtrack_stackpointer(), 0)); 255 __ Branch(&backtrack_non_equal, ne, current_input_offset(), Operand(a0)); 256 __ Daddu(backtrack_stackpointer(), 257 backtrack_stackpointer(), 258 Operand(kIntSize)); 259 __ bind(&backtrack_non_equal); 260 BranchOrBacktrack(on_equal, eq, current_input_offset(), Operand(a0)); 261 } 262 263 264 void RegExpMacroAssemblerMIPS::CheckNotBackReferenceIgnoreCase( 265 int start_reg, 266 Label* on_no_match) { 267 Label fallthrough; 268 __ ld(a0, register_location(start_reg)); // Index of start of capture. 269 __ ld(a1, register_location(start_reg + 1)); // Index of end of capture. 270 __ Dsubu(a1, a1, a0); // Length of capture. 271 272 // If length is zero, either the capture is empty or it is not participating. 273 // In either case succeed immediately. 274 __ Branch(&fallthrough, eq, a1, Operand(zero_reg)); 275 276 __ Daddu(t1, a1, current_input_offset()); 277 // Check that there are enough characters left in the input. 278 BranchOrBacktrack(on_no_match, gt, t1, Operand(zero_reg)); 279 280 if (mode_ == LATIN1) { 281 Label success; 282 Label fail; 283 Label loop_check; 284 285 // a0 - offset of start of capture. 286 // a1 - length of capture. 287 __ Daddu(a0, a0, Operand(end_of_input_address())); 288 __ Daddu(a2, end_of_input_address(), Operand(current_input_offset())); 289 __ Daddu(a1, a0, Operand(a1)); 290 291 // a0 - Address of start of capture. 292 // a1 - Address of end of capture. 293 // a2 - Address of current input position. 294 295 Label loop; 296 __ bind(&loop); 297 __ lbu(a3, MemOperand(a0, 0)); 298 __ daddiu(a0, a0, char_size()); 299 __ lbu(a4, MemOperand(a2, 0)); 300 __ daddiu(a2, a2, char_size()); 301 302 __ Branch(&loop_check, eq, a4, Operand(a3)); 303 304 // Mismatch, try case-insensitive match (converting letters to lower-case). 305 __ Or(a3, a3, Operand(0x20)); // Convert capture character to lower-case. 306 __ Or(a4, a4, Operand(0x20)); // Also convert input character. 307 __ Branch(&fail, ne, a4, Operand(a3)); 308 __ Dsubu(a3, a3, Operand('a')); 309 __ Branch(&loop_check, ls, a3, Operand('z' - 'a')); 310 // Latin-1: Check for values in range [224,254] but not 247. 311 __ Dsubu(a3, a3, Operand(224 - 'a')); 312 // Weren't Latin-1 letters. 313 __ Branch(&fail, hi, a3, Operand(254 - 224)); 314 // Check for 247. 315 __ Branch(&fail, eq, a3, Operand(247 - 224)); 316 317 __ bind(&loop_check); 318 __ Branch(&loop, lt, a0, Operand(a1)); 319 __ jmp(&success); 320 321 __ bind(&fail); 322 GoTo(on_no_match); 323 324 __ bind(&success); 325 // Compute new value of character position after the matched part. 326 __ Dsubu(current_input_offset(), a2, end_of_input_address()); 327 } else { 328 DCHECK(mode_ == UC16); 329 // Put regexp engine registers on stack. 330 RegList regexp_registers_to_retain = current_input_offset().bit() | 331 current_character().bit() | backtrack_stackpointer().bit(); 332 __ MultiPush(regexp_registers_to_retain); 333 334 int argument_count = 4; 335 __ PrepareCallCFunction(argument_count, a2); 336 337 // a0 - offset of start of capture. 338 // a1 - length of capture. 339 340 // Put arguments into arguments registers. 341 // Parameters are 342 // a0: Address byte_offset1 - Address captured substring's start. 343 // a1: Address byte_offset2 - Address of current character position. 344 // a2: size_t byte_length - length of capture in bytes(!). 345 // a3: Isolate* isolate. 346 347 // Address of start of capture. 348 __ Daddu(a0, a0, Operand(end_of_input_address())); 349 // Length of capture. 350 __ mov(a2, a1); 351 // Save length in callee-save register for use on return. 352 __ mov(s3, a1); 353 // Address of current input position. 354 __ Daddu(a1, current_input_offset(), Operand(end_of_input_address())); 355 // Isolate. 356 __ li(a3, Operand(ExternalReference::isolate_address(masm_->isolate()))); 357 358 { 359 AllowExternalCallThatCantCauseGC scope(masm_); 360 ExternalReference function = 361 ExternalReference::re_case_insensitive_compare_uc16(masm_->isolate()); 362 __ CallCFunction(function, argument_count); 363 } 364 365 // Restore regexp engine registers. 366 __ MultiPop(regexp_registers_to_retain); 367 __ li(code_pointer(), Operand(masm_->CodeObject()), CONSTANT_SIZE); 368 __ ld(end_of_input_address(), MemOperand(frame_pointer(), kInputEnd)); 369 370 // Check if function returned non-zero for success or zero for failure. 371 BranchOrBacktrack(on_no_match, eq, v0, Operand(zero_reg)); 372 // On success, increment position by length of capture. 373 __ Daddu(current_input_offset(), current_input_offset(), Operand(s3)); 374 } 375 376 __ bind(&fallthrough); 377 } 378 379 380 void RegExpMacroAssemblerMIPS::CheckNotBackReference( 381 int start_reg, 382 Label* on_no_match) { 383 Label fallthrough; 384 Label success; 385 386 // Find length of back-referenced capture. 387 __ ld(a0, register_location(start_reg)); 388 __ ld(a1, register_location(start_reg + 1)); 389 __ Dsubu(a1, a1, a0); // Length to check. 390 // Succeed on empty capture (including no capture). 391 __ Branch(&fallthrough, eq, a1, Operand(zero_reg)); 392 393 __ Daddu(t1, a1, current_input_offset()); 394 // Check that there are enough characters left in the input. 395 BranchOrBacktrack(on_no_match, gt, t1, Operand(zero_reg)); 396 397 // Compute pointers to match string and capture string. 398 __ Daddu(a0, a0, Operand(end_of_input_address())); 399 __ Daddu(a2, end_of_input_address(), Operand(current_input_offset())); 400 __ Daddu(a1, a1, Operand(a0)); 401 402 Label loop; 403 __ bind(&loop); 404 if (mode_ == LATIN1) { 405 __ lbu(a3, MemOperand(a0, 0)); 406 __ daddiu(a0, a0, char_size()); 407 __ lbu(a4, MemOperand(a2, 0)); 408 __ daddiu(a2, a2, char_size()); 409 } else { 410 DCHECK(mode_ == UC16); 411 __ lhu(a3, MemOperand(a0, 0)); 412 __ daddiu(a0, a0, char_size()); 413 __ lhu(a4, MemOperand(a2, 0)); 414 __ daddiu(a2, a2, char_size()); 415 } 416 BranchOrBacktrack(on_no_match, ne, a3, Operand(a4)); 417 __ Branch(&loop, lt, a0, Operand(a1)); 418 419 // Move current character position to position after match. 420 __ Dsubu(current_input_offset(), a2, end_of_input_address()); 421 __ bind(&fallthrough); 422 } 423 424 425 void RegExpMacroAssemblerMIPS::CheckNotCharacter(uint32_t c, 426 Label* on_not_equal) { 427 BranchOrBacktrack(on_not_equal, ne, current_character(), Operand(c)); 428 } 429 430 431 void RegExpMacroAssemblerMIPS::CheckCharacterAfterAnd(uint32_t c, 432 uint32_t mask, 433 Label* on_equal) { 434 __ And(a0, current_character(), Operand(mask)); 435 Operand rhs = (c == 0) ? Operand(zero_reg) : Operand(c); 436 BranchOrBacktrack(on_equal, eq, a0, rhs); 437 } 438 439 440 void RegExpMacroAssemblerMIPS::CheckNotCharacterAfterAnd(uint32_t c, 441 uint32_t mask, 442 Label* on_not_equal) { 443 __ And(a0, current_character(), Operand(mask)); 444 Operand rhs = (c == 0) ? Operand(zero_reg) : Operand(c); 445 BranchOrBacktrack(on_not_equal, ne, a0, rhs); 446 } 447 448 449 void RegExpMacroAssemblerMIPS::CheckNotCharacterAfterMinusAnd( 450 uc16 c, 451 uc16 minus, 452 uc16 mask, 453 Label* on_not_equal) { 454 DCHECK(minus < String::kMaxUtf16CodeUnit); 455 __ Dsubu(a0, current_character(), Operand(minus)); 456 __ And(a0, a0, Operand(mask)); 457 BranchOrBacktrack(on_not_equal, ne, a0, Operand(c)); 458 } 459 460 461 void RegExpMacroAssemblerMIPS::CheckCharacterInRange( 462 uc16 from, 463 uc16 to, 464 Label* on_in_range) { 465 __ Dsubu(a0, current_character(), Operand(from)); 466 // Unsigned lower-or-same condition. 467 BranchOrBacktrack(on_in_range, ls, a0, Operand(to - from)); 468 } 469 470 471 void RegExpMacroAssemblerMIPS::CheckCharacterNotInRange( 472 uc16 from, 473 uc16 to, 474 Label* on_not_in_range) { 475 __ Dsubu(a0, current_character(), Operand(from)); 476 // Unsigned higher condition. 477 BranchOrBacktrack(on_not_in_range, hi, a0, Operand(to - from)); 478 } 479 480 481 void RegExpMacroAssemblerMIPS::CheckBitInTable( 482 Handle<ByteArray> table, 483 Label* on_bit_set) { 484 __ li(a0, Operand(table)); 485 if (mode_ != LATIN1 || kTableMask != String::kMaxOneByteCharCode) { 486 __ And(a1, current_character(), Operand(kTableSize - 1)); 487 __ Daddu(a0, a0, a1); 488 } else { 489 __ Daddu(a0, a0, current_character()); 490 } 491 492 __ lbu(a0, FieldMemOperand(a0, ByteArray::kHeaderSize)); 493 BranchOrBacktrack(on_bit_set, ne, a0, Operand(zero_reg)); 494 } 495 496 497 bool RegExpMacroAssemblerMIPS::CheckSpecialCharacterClass(uc16 type, 498 Label* on_no_match) { 499 // Range checks (c in min..max) are generally implemented by an unsigned 500 // (c - min) <= (max - min) check. 501 switch (type) { 502 case 's': 503 // Match space-characters. 504 if (mode_ == LATIN1) { 505 // One byte space characters are '\t'..'\r', ' ' and \u00a0. 506 Label success; 507 __ Branch(&success, eq, current_character(), Operand(' ')); 508 // Check range 0x09..0x0d. 509 __ Dsubu(a0, current_character(), Operand('\t')); 510 __ Branch(&success, ls, a0, Operand('\r' - '\t')); 511 // \u00a0 (NBSP). 512 BranchOrBacktrack(on_no_match, ne, a0, Operand(0x00a0 - '\t')); 513 __ bind(&success); 514 return true; 515 } 516 return false; 517 case 'S': 518 // The emitted code for generic character classes is good enough. 519 return false; 520 case 'd': 521 // Match Latin1 digits ('0'..'9'). 522 __ Dsubu(a0, current_character(), Operand('0')); 523 BranchOrBacktrack(on_no_match, hi, a0, Operand('9' - '0')); 524 return true; 525 case 'D': 526 // Match non Latin1-digits. 527 __ Dsubu(a0, current_character(), Operand('0')); 528 BranchOrBacktrack(on_no_match, ls, a0, Operand('9' - '0')); 529 return true; 530 case '.': { 531 // Match non-newlines (not 0x0a('\n'), 0x0d('\r'), 0x2028 and 0x2029). 532 __ Xor(a0, current_character(), Operand(0x01)); 533 // See if current character is '\n'^1 or '\r'^1, i.e., 0x0b or 0x0c. 534 __ Dsubu(a0, a0, Operand(0x0b)); 535 BranchOrBacktrack(on_no_match, ls, a0, Operand(0x0c - 0x0b)); 536 if (mode_ == UC16) { 537 // Compare original value to 0x2028 and 0x2029, using the already 538 // computed (current_char ^ 0x01 - 0x0b). I.e., check for 539 // 0x201d (0x2028 - 0x0b) or 0x201e. 540 __ Dsubu(a0, a0, Operand(0x2028 - 0x0b)); 541 BranchOrBacktrack(on_no_match, ls, a0, Operand(1)); 542 } 543 return true; 544 } 545 case 'n': { 546 // Match newlines (0x0a('\n'), 0x0d('\r'), 0x2028 and 0x2029). 547 __ Xor(a0, current_character(), Operand(0x01)); 548 // See if current character is '\n'^1 or '\r'^1, i.e., 0x0b or 0x0c. 549 __ Dsubu(a0, a0, Operand(0x0b)); 550 if (mode_ == LATIN1) { 551 BranchOrBacktrack(on_no_match, hi, a0, Operand(0x0c - 0x0b)); 552 } else { 553 Label done; 554 BranchOrBacktrack(&done, ls, a0, Operand(0x0c - 0x0b)); 555 // Compare original value to 0x2028 and 0x2029, using the already 556 // computed (current_char ^ 0x01 - 0x0b). I.e., check for 557 // 0x201d (0x2028 - 0x0b) or 0x201e. 558 __ Dsubu(a0, a0, Operand(0x2028 - 0x0b)); 559 BranchOrBacktrack(on_no_match, hi, a0, Operand(1)); 560 __ bind(&done); 561 } 562 return true; 563 } 564 case 'w': { 565 if (mode_ != LATIN1) { 566 // Table is 256 entries, so all Latin1 characters can be tested. 567 BranchOrBacktrack(on_no_match, hi, current_character(), Operand('z')); 568 } 569 ExternalReference map = ExternalReference::re_word_character_map(); 570 __ li(a0, Operand(map)); 571 __ Daddu(a0, a0, current_character()); 572 __ lbu(a0, MemOperand(a0, 0)); 573 BranchOrBacktrack(on_no_match, eq, a0, Operand(zero_reg)); 574 return true; 575 } 576 case 'W': { 577 Label done; 578 if (mode_ != LATIN1) { 579 // Table is 256 entries, so all Latin1 characters can be tested. 580 __ Branch(&done, hi, current_character(), Operand('z')); 581 } 582 ExternalReference map = ExternalReference::re_word_character_map(); 583 __ li(a0, Operand(map)); 584 __ Daddu(a0, a0, current_character()); 585 __ lbu(a0, MemOperand(a0, 0)); 586 BranchOrBacktrack(on_no_match, ne, a0, Operand(zero_reg)); 587 if (mode_ != LATIN1) { 588 __ bind(&done); 589 } 590 return true; 591 } 592 case '*': 593 // Match any character. 594 return true; 595 // No custom implementation (yet): s(UC16), S(UC16). 596 default: 597 return false; 598 } 599 } 600 601 602 void RegExpMacroAssemblerMIPS::Fail() { 603 __ li(v0, Operand(FAILURE)); 604 __ jmp(&exit_label_); 605 } 606 607 608 Handle<HeapObject> RegExpMacroAssemblerMIPS::GetCode(Handle<String> source) { 609 Label return_v0; 610 if (masm_->has_exception()) { 611 // If the code gets corrupted due to long regular expressions and lack of 612 // space on trampolines, an internal exception flag is set. If this case 613 // is detected, we will jump into exit sequence right away. 614 __ bind_to(&entry_label_, internal_failure_label_.pos()); 615 } else { 616 // Finalize code - write the entry point code now we know how many 617 // registers we need. 618 619 // Entry code: 620 __ bind(&entry_label_); 621 622 // Tell the system that we have a stack frame. Because the type is MANUAL, 623 // no is generated. 624 FrameScope scope(masm_, StackFrame::MANUAL); 625 626 // Actually emit code to start a new stack frame. 627 // Push arguments 628 // Save callee-save registers. 629 // Start new stack frame. 630 // Store link register in existing stack-cell. 631 // Order here should correspond to order of offset constants in header file. 632 // TODO(plind): we save s0..s7, but ONLY use s3 here - use the regs 633 // or dont save. 634 RegList registers_to_retain = s0.bit() | s1.bit() | s2.bit() | 635 s3.bit() | s4.bit() | s5.bit() | s6.bit() | s7.bit() | fp.bit(); 636 RegList argument_registers = a0.bit() | a1.bit() | a2.bit() | a3.bit(); 637 638 if (kMipsAbi == kN64) { 639 // TODO(plind): Should probably alias a4-a7, for clarity. 640 argument_registers |= a4.bit() | a5.bit() | a6.bit() | a7.bit(); 641 } 642 643 __ MultiPush(argument_registers | registers_to_retain | ra.bit()); 644 // Set frame pointer in space for it if this is not a direct call 645 // from generated code. 646 // TODO(plind): this 8 is the # of argument regs, should have definition. 647 __ Daddu(frame_pointer(), sp, Operand(8 * kPointerSize)); 648 __ mov(a0, zero_reg); 649 __ push(a0); // Make room for success counter and initialize it to 0. 650 __ push(a0); // Make room for "position - 1" constant (value irrelevant). 651 652 // Check if we have space on the stack for registers. 653 Label stack_limit_hit; 654 Label stack_ok; 655 656 ExternalReference stack_limit = 657 ExternalReference::address_of_stack_limit(masm_->isolate()); 658 __ li(a0, Operand(stack_limit)); 659 __ ld(a0, MemOperand(a0)); 660 __ Dsubu(a0, sp, a0); 661 // Handle it if the stack pointer is already below the stack limit. 662 __ Branch(&stack_limit_hit, le, a0, Operand(zero_reg)); 663 // Check if there is room for the variable number of registers above 664 // the stack limit. 665 __ Branch(&stack_ok, hs, a0, Operand(num_registers_ * kPointerSize)); 666 // Exit with OutOfMemory exception. There is not enough space on the stack 667 // for our working registers. 668 __ li(v0, Operand(EXCEPTION)); 669 __ jmp(&return_v0); 670 671 __ bind(&stack_limit_hit); 672 CallCheckStackGuardState(a0); 673 // If returned value is non-zero, we exit with the returned value as result. 674 __ Branch(&return_v0, ne, v0, Operand(zero_reg)); 675 676 __ bind(&stack_ok); 677 // Allocate space on stack for registers. 678 __ Dsubu(sp, sp, Operand(num_registers_ * kPointerSize)); 679 // Load string end. 680 __ ld(end_of_input_address(), MemOperand(frame_pointer(), kInputEnd)); 681 // Load input start. 682 __ ld(a0, MemOperand(frame_pointer(), kInputStart)); 683 // Find negative length (offset of start relative to end). 684 __ Dsubu(current_input_offset(), a0, end_of_input_address()); 685 // Set a0 to address of char before start of the input string 686 // (effectively string position -1). 687 __ ld(a1, MemOperand(frame_pointer(), kStartIndex)); 688 __ Dsubu(a0, current_input_offset(), Operand(char_size())); 689 __ dsll(t1, a1, (mode_ == UC16) ? 1 : 0); 690 __ Dsubu(a0, a0, t1); 691 // Store this value in a local variable, for use when clearing 692 // position registers. 693 __ sd(a0, MemOperand(frame_pointer(), kInputStartMinusOne)); 694 695 // Initialize code pointer register 696 __ li(code_pointer(), Operand(masm_->CodeObject()), CONSTANT_SIZE); 697 698 Label load_char_start_regexp, start_regexp; 699 // Load newline if index is at start, previous character otherwise. 700 __ Branch(&load_char_start_regexp, ne, a1, Operand(zero_reg)); 701 __ li(current_character(), Operand('\n')); 702 __ jmp(&start_regexp); 703 704 // Global regexp restarts matching here. 705 __ bind(&load_char_start_regexp); 706 // Load previous char as initial value of current character register. 707 LoadCurrentCharacterUnchecked(-1, 1); 708 __ bind(&start_regexp); 709 710 // Initialize on-stack registers. 711 if (num_saved_registers_ > 0) { // Always is, if generated from a regexp. 712 // Fill saved registers with initial value = start offset - 1. 713 if (num_saved_registers_ > 8) { 714 // Address of register 0. 715 __ Daddu(a1, frame_pointer(), Operand(kRegisterZero)); 716 __ li(a2, Operand(num_saved_registers_)); 717 Label init_loop; 718 __ bind(&init_loop); 719 __ sd(a0, MemOperand(a1)); 720 __ Daddu(a1, a1, Operand(-kPointerSize)); 721 __ Dsubu(a2, a2, Operand(1)); 722 __ Branch(&init_loop, ne, a2, Operand(zero_reg)); 723 } else { 724 for (int i = 0; i < num_saved_registers_; i++) { 725 __ sd(a0, register_location(i)); 726 } 727 } 728 } 729 730 // Initialize backtrack stack pointer. 731 __ ld(backtrack_stackpointer(), MemOperand(frame_pointer(), kStackHighEnd)); 732 733 __ jmp(&start_label_); 734 735 736 // Exit code: 737 if (success_label_.is_linked()) { 738 // Save captures when successful. 739 __ bind(&success_label_); 740 if (num_saved_registers_ > 0) { 741 // Copy captures to output. 742 __ ld(a1, MemOperand(frame_pointer(), kInputStart)); 743 __ ld(a0, MemOperand(frame_pointer(), kRegisterOutput)); 744 __ ld(a2, MemOperand(frame_pointer(), kStartIndex)); 745 __ Dsubu(a1, end_of_input_address(), a1); 746 // a1 is length of input in bytes. 747 if (mode_ == UC16) { 748 __ dsrl(a1, a1, 1); 749 } 750 // a1 is length of input in characters. 751 __ Daddu(a1, a1, Operand(a2)); 752 // a1 is length of string in characters. 753 754 DCHECK_EQ(0, num_saved_registers_ % 2); 755 // Always an even number of capture registers. This allows us to 756 // unroll the loop once to add an operation between a load of a register 757 // and the following use of that register. 758 for (int i = 0; i < num_saved_registers_; i += 2) { 759 __ ld(a2, register_location(i)); 760 __ ld(a3, register_location(i + 1)); 761 if (i == 0 && global_with_zero_length_check()) { 762 // Keep capture start in a4 for the zero-length check later. 763 __ mov(t3, a2); 764 } 765 if (mode_ == UC16) { 766 __ dsra(a2, a2, 1); 767 __ Daddu(a2, a2, a1); 768 __ dsra(a3, a3, 1); 769 __ Daddu(a3, a3, a1); 770 } else { 771 __ Daddu(a2, a1, Operand(a2)); 772 __ Daddu(a3, a1, Operand(a3)); 773 } 774 // V8 expects the output to be an int32_t array. 775 __ sw(a2, MemOperand(a0)); 776 __ Daddu(a0, a0, kIntSize); 777 __ sw(a3, MemOperand(a0)); 778 __ Daddu(a0, a0, kIntSize); 779 } 780 } 781 782 if (global()) { 783 // Restart matching if the regular expression is flagged as global. 784 __ ld(a0, MemOperand(frame_pointer(), kSuccessfulCaptures)); 785 __ lw(a1, MemOperand(frame_pointer(), kNumOutputRegisters)); 786 __ ld(a2, MemOperand(frame_pointer(), kRegisterOutput)); 787 // Increment success counter. 788 __ Daddu(a0, a0, 1); 789 __ sd(a0, MemOperand(frame_pointer(), kSuccessfulCaptures)); 790 // Capture results have been stored, so the number of remaining global 791 // output registers is reduced by the number of stored captures. 792 __ Dsubu(a1, a1, num_saved_registers_); 793 // Check whether we have enough room for another set of capture results. 794 __ mov(v0, a0); 795 __ Branch(&return_v0, lt, a1, Operand(num_saved_registers_)); 796 797 __ sd(a1, MemOperand(frame_pointer(), kNumOutputRegisters)); 798 // Advance the location for output. 799 __ Daddu(a2, a2, num_saved_registers_ * kIntSize); 800 __ sd(a2, MemOperand(frame_pointer(), kRegisterOutput)); 801 802 // Prepare a0 to initialize registers with its value in the next run. 803 __ ld(a0, MemOperand(frame_pointer(), kInputStartMinusOne)); 804 805 if (global_with_zero_length_check()) { 806 // Special case for zero-length matches. 807 // t3: capture start index 808 // Not a zero-length match, restart. 809 __ Branch( 810 &load_char_start_regexp, ne, current_input_offset(), Operand(t3)); 811 // Offset from the end is zero if we already reached the end. 812 __ Branch(&exit_label_, eq, current_input_offset(), 813 Operand(zero_reg)); 814 // Advance current position after a zero-length match. 815 __ Daddu(current_input_offset(), 816 current_input_offset(), 817 Operand((mode_ == UC16) ? 2 : 1)); 818 } 819 820 __ Branch(&load_char_start_regexp); 821 } else { 822 __ li(v0, Operand(SUCCESS)); 823 } 824 } 825 // Exit and return v0. 826 __ bind(&exit_label_); 827 if (global()) { 828 __ ld(v0, MemOperand(frame_pointer(), kSuccessfulCaptures)); 829 } 830 831 __ bind(&return_v0); 832 // Skip sp past regexp registers and local variables.. 833 __ mov(sp, frame_pointer()); 834 // Restore registers s0..s7 and return (restoring ra to pc). 835 __ MultiPop(registers_to_retain | ra.bit()); 836 __ Ret(); 837 838 // Backtrack code (branch target for conditional backtracks). 839 if (backtrack_label_.is_linked()) { 840 __ bind(&backtrack_label_); 841 Backtrack(); 842 } 843 844 Label exit_with_exception; 845 846 // Preempt-code. 847 if (check_preempt_label_.is_linked()) { 848 SafeCallTarget(&check_preempt_label_); 849 // Put regexp engine registers on stack. 850 RegList regexp_registers_to_retain = current_input_offset().bit() | 851 current_character().bit() | backtrack_stackpointer().bit(); 852 __ MultiPush(regexp_registers_to_retain); 853 CallCheckStackGuardState(a0); 854 __ MultiPop(regexp_registers_to_retain); 855 // If returning non-zero, we should end execution with the given 856 // result as return value. 857 __ Branch(&return_v0, ne, v0, Operand(zero_reg)); 858 859 // String might have moved: Reload end of string from frame. 860 __ ld(end_of_input_address(), MemOperand(frame_pointer(), kInputEnd)); 861 __ li(code_pointer(), Operand(masm_->CodeObject()), CONSTANT_SIZE); 862 SafeReturn(); 863 } 864 865 // Backtrack stack overflow code. 866 if (stack_overflow_label_.is_linked()) { 867 SafeCallTarget(&stack_overflow_label_); 868 // Reached if the backtrack-stack limit has been hit. 869 // Put regexp engine registers on stack first. 870 RegList regexp_registers = current_input_offset().bit() | 871 current_character().bit(); 872 __ MultiPush(regexp_registers); 873 Label grow_failed; 874 // Call GrowStack(backtrack_stackpointer(), &stack_base) 875 static const int num_arguments = 3; 876 __ PrepareCallCFunction(num_arguments, a0); 877 __ mov(a0, backtrack_stackpointer()); 878 __ Daddu(a1, frame_pointer(), Operand(kStackHighEnd)); 879 __ li(a2, Operand(ExternalReference::isolate_address(masm_->isolate()))); 880 ExternalReference grow_stack = 881 ExternalReference::re_grow_stack(masm_->isolate()); 882 __ CallCFunction(grow_stack, num_arguments); 883 // Restore regexp registers. 884 __ MultiPop(regexp_registers); 885 // If return NULL, we have failed to grow the stack, and 886 // must exit with a stack-overflow exception. 887 __ Branch(&exit_with_exception, eq, v0, Operand(zero_reg)); 888 // Otherwise use return value as new stack pointer. 889 __ mov(backtrack_stackpointer(), v0); 890 // Restore saved registers and continue. 891 __ li(code_pointer(), Operand(masm_->CodeObject()), CONSTANT_SIZE); 892 __ ld(end_of_input_address(), MemOperand(frame_pointer(), kInputEnd)); 893 SafeReturn(); 894 } 895 896 if (exit_with_exception.is_linked()) { 897 // If any of the code above needed to exit with an exception. 898 __ bind(&exit_with_exception); 899 // Exit with Result EXCEPTION(-1) to signal thrown exception. 900 __ li(v0, Operand(EXCEPTION)); 901 __ jmp(&return_v0); 902 } 903 } 904 905 CodeDesc code_desc; 906 masm_->GetCode(&code_desc); 907 Handle<Code> code = isolate()->factory()->NewCode( 908 code_desc, Code::ComputeFlags(Code::REGEXP), masm_->CodeObject()); 909 LOG(masm_->isolate(), RegExpCodeCreateEvent(*code, *source)); 910 return Handle<HeapObject>::cast(code); 911 } 912 913 914 void RegExpMacroAssemblerMIPS::GoTo(Label* to) { 915 if (to == NULL) { 916 Backtrack(); 917 return; 918 } 919 __ jmp(to); 920 return; 921 } 922 923 924 void RegExpMacroAssemblerMIPS::IfRegisterGE(int reg, 925 int comparand, 926 Label* if_ge) { 927 __ ld(a0, register_location(reg)); 928 BranchOrBacktrack(if_ge, ge, a0, Operand(comparand)); 929 } 930 931 932 void RegExpMacroAssemblerMIPS::IfRegisterLT(int reg, 933 int comparand, 934 Label* if_lt) { 935 __ ld(a0, register_location(reg)); 936 BranchOrBacktrack(if_lt, lt, a0, Operand(comparand)); 937 } 938 939 940 void RegExpMacroAssemblerMIPS::IfRegisterEqPos(int reg, 941 Label* if_eq) { 942 __ ld(a0, register_location(reg)); 943 BranchOrBacktrack(if_eq, eq, a0, Operand(current_input_offset())); 944 } 945 946 947 RegExpMacroAssembler::IrregexpImplementation 948 RegExpMacroAssemblerMIPS::Implementation() { 949 return kMIPSImplementation; 950 } 951 952 953 void RegExpMacroAssemblerMIPS::LoadCurrentCharacter(int cp_offset, 954 Label* on_end_of_input, 955 bool check_bounds, 956 int characters) { 957 DCHECK(cp_offset >= -1); // ^ and \b can look behind one character. 958 DCHECK(cp_offset < (1<<30)); // Be sane! (And ensure negation works). 959 if (check_bounds) { 960 CheckPosition(cp_offset + characters - 1, on_end_of_input); 961 } 962 LoadCurrentCharacterUnchecked(cp_offset, characters); 963 } 964 965 966 void RegExpMacroAssemblerMIPS::PopCurrentPosition() { 967 Pop(current_input_offset()); 968 } 969 970 971 void RegExpMacroAssemblerMIPS::PopRegister(int register_index) { 972 Pop(a0); 973 __ sd(a0, register_location(register_index)); 974 } 975 976 977 void RegExpMacroAssemblerMIPS::PushBacktrack(Label* label) { 978 if (label->is_bound()) { 979 int target = label->pos(); 980 __ li(a0, Operand(target + Code::kHeaderSize - kHeapObjectTag)); 981 } else { 982 Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_); 983 Label after_constant; 984 __ Branch(&after_constant); 985 int offset = masm_->pc_offset(); 986 int cp_offset = offset + Code::kHeaderSize - kHeapObjectTag; 987 __ emit(0); 988 masm_->label_at_put(label, offset); 989 __ bind(&after_constant); 990 if (is_int16(cp_offset)) { 991 __ lwu(a0, MemOperand(code_pointer(), cp_offset)); 992 } else { 993 __ Daddu(a0, code_pointer(), cp_offset); 994 __ lwu(a0, MemOperand(a0, 0)); 995 } 996 } 997 Push(a0); 998 CheckStackLimit(); 999 } 1000 1001 1002 void RegExpMacroAssemblerMIPS::PushCurrentPosition() { 1003 Push(current_input_offset()); 1004 } 1005 1006 1007 void RegExpMacroAssemblerMIPS::PushRegister(int register_index, 1008 StackCheckFlag check_stack_limit) { 1009 __ ld(a0, register_location(register_index)); 1010 Push(a0); 1011 if (check_stack_limit) CheckStackLimit(); 1012 } 1013 1014 1015 void RegExpMacroAssemblerMIPS::ReadCurrentPositionFromRegister(int reg) { 1016 __ ld(current_input_offset(), register_location(reg)); 1017 } 1018 1019 1020 void RegExpMacroAssemblerMIPS::ReadStackPointerFromRegister(int reg) { 1021 __ ld(backtrack_stackpointer(), register_location(reg)); 1022 __ ld(a0, MemOperand(frame_pointer(), kStackHighEnd)); 1023 __ Daddu(backtrack_stackpointer(), backtrack_stackpointer(), Operand(a0)); 1024 } 1025 1026 1027 void RegExpMacroAssemblerMIPS::SetCurrentPositionFromEnd(int by) { 1028 Label after_position; 1029 __ Branch(&after_position, 1030 ge, 1031 current_input_offset(), 1032 Operand(-by * char_size())); 1033 __ li(current_input_offset(), -by * char_size()); 1034 // On RegExp code entry (where this operation is used), the character before 1035 // the current position is expected to be already loaded. 1036 // We have advanced the position, so it's safe to read backwards. 1037 LoadCurrentCharacterUnchecked(-1, 1); 1038 __ bind(&after_position); 1039 } 1040 1041 1042 void RegExpMacroAssemblerMIPS::SetRegister(int register_index, int to) { 1043 DCHECK(register_index >= num_saved_registers_); // Reserved for positions! 1044 __ li(a0, Operand(to)); 1045 __ sd(a0, register_location(register_index)); 1046 } 1047 1048 1049 bool RegExpMacroAssemblerMIPS::Succeed() { 1050 __ jmp(&success_label_); 1051 return global(); 1052 } 1053 1054 1055 void RegExpMacroAssemblerMIPS::WriteCurrentPositionToRegister(int reg, 1056 int cp_offset) { 1057 if (cp_offset == 0) { 1058 __ sd(current_input_offset(), register_location(reg)); 1059 } else { 1060 __ Daddu(a0, current_input_offset(), Operand(cp_offset * char_size())); 1061 __ sd(a0, register_location(reg)); 1062 } 1063 } 1064 1065 1066 void RegExpMacroAssemblerMIPS::ClearRegisters(int reg_from, int reg_to) { 1067 DCHECK(reg_from <= reg_to); 1068 __ ld(a0, MemOperand(frame_pointer(), kInputStartMinusOne)); 1069 for (int reg = reg_from; reg <= reg_to; reg++) { 1070 __ sd(a0, register_location(reg)); 1071 } 1072 } 1073 1074 1075 void RegExpMacroAssemblerMIPS::WriteStackPointerToRegister(int reg) { 1076 __ ld(a1, MemOperand(frame_pointer(), kStackHighEnd)); 1077 __ Dsubu(a0, backtrack_stackpointer(), a1); 1078 __ sd(a0, register_location(reg)); 1079 } 1080 1081 1082 bool RegExpMacroAssemblerMIPS::CanReadUnaligned() { 1083 return false; 1084 } 1085 1086 1087 // Private methods: 1088 1089 void RegExpMacroAssemblerMIPS::CallCheckStackGuardState(Register scratch) { 1090 int stack_alignment = base::OS::ActivationFrameAlignment(); 1091 1092 // Align the stack pointer and save the original sp value on the stack. 1093 __ mov(scratch, sp); 1094 __ Dsubu(sp, sp, Operand(kPointerSize)); 1095 DCHECK(base::bits::IsPowerOfTwo32(stack_alignment)); 1096 __ And(sp, sp, Operand(-stack_alignment)); 1097 __ sd(scratch, MemOperand(sp)); 1098 1099 __ mov(a2, frame_pointer()); 1100 // Code* of self. 1101 __ li(a1, Operand(masm_->CodeObject()), CONSTANT_SIZE); 1102 1103 // We need to make room for the return address on the stack. 1104 DCHECK(IsAligned(stack_alignment, kPointerSize)); 1105 __ Dsubu(sp, sp, Operand(stack_alignment)); 1106 1107 // Stack pointer now points to cell where return address is to be written. 1108 // Arguments are in registers, meaning we teat the return address as 1109 // argument 5. Since DirectCEntryStub will handleallocating space for the C 1110 // argument slots, we don't need to care about that here. This is how the 1111 // stack will look (sp meaning the value of sp at this moment): 1112 // [sp + 3] - empty slot if needed for alignment. 1113 // [sp + 2] - saved sp. 1114 // [sp + 1] - second word reserved for return value. 1115 // [sp + 0] - first word reserved for return value. 1116 1117 // a0 will point to the return address, placed by DirectCEntry. 1118 __ mov(a0, sp); 1119 1120 ExternalReference stack_guard_check = 1121 ExternalReference::re_check_stack_guard_state(masm_->isolate()); 1122 __ li(t9, Operand(stack_guard_check)); 1123 DirectCEntryStub stub(isolate()); 1124 stub.GenerateCall(masm_, t9); 1125 1126 // DirectCEntryStub allocated space for the C argument slots so we have to 1127 // drop them with the return address from the stack with loading saved sp. 1128 // At this point stack must look: 1129 // [sp + 7] - empty slot if needed for alignment. 1130 // [sp + 6] - saved sp. 1131 // [sp + 5] - second word reserved for return value. 1132 // [sp + 4] - first word reserved for return value. 1133 // [sp + 3] - C argument slot. 1134 // [sp + 2] - C argument slot. 1135 // [sp + 1] - C argument slot. 1136 // [sp + 0] - C argument slot. 1137 __ ld(sp, MemOperand(sp, stack_alignment + kCArgsSlotsSize)); 1138 1139 __ li(code_pointer(), Operand(masm_->CodeObject())); 1140 } 1141 1142 1143 // Helper function for reading a value out of a stack frame. 1144 template <typename T> 1145 static T& frame_entry(Address re_frame, int frame_offset) { 1146 return reinterpret_cast<T&>(Memory::int32_at(re_frame + frame_offset)); 1147 } 1148 1149 1150 int RegExpMacroAssemblerMIPS::CheckStackGuardState(Address* return_address, 1151 Code* re_code, 1152 Address re_frame) { 1153 Isolate* isolate = frame_entry<Isolate*>(re_frame, kIsolate); 1154 StackLimitCheck check(isolate); 1155 if (check.JsHasOverflowed()) { 1156 isolate->StackOverflow(); 1157 return EXCEPTION; 1158 } 1159 1160 // If not real stack overflow the stack guard was used to interrupt 1161 // execution for another purpose. 1162 1163 // If this is a direct call from JavaScript retry the RegExp forcing the call 1164 // through the runtime system. Currently the direct call cannot handle a GC. 1165 if (frame_entry<int>(re_frame, kDirectCall) == 1) { 1166 return RETRY; 1167 } 1168 1169 // Prepare for possible GC. 1170 HandleScope handles(isolate); 1171 Handle<Code> code_handle(re_code); 1172 1173 Handle<String> subject(frame_entry<String*>(re_frame, kInputString)); 1174 // Current string. 1175 bool is_one_byte = subject->IsOneByteRepresentationUnderneath(); 1176 1177 DCHECK(re_code->instruction_start() <= *return_address); 1178 DCHECK(*return_address <= 1179 re_code->instruction_start() + re_code->instruction_size()); 1180 1181 Object* result = isolate->stack_guard()->HandleInterrupts(); 1182 1183 if (*code_handle != re_code) { // Return address no longer valid. 1184 int delta = code_handle->address() - re_code->address(); 1185 // Overwrite the return address on the stack. 1186 *return_address += delta; 1187 } 1188 1189 if (result->IsException()) { 1190 return EXCEPTION; 1191 } 1192 1193 Handle<String> subject_tmp = subject; 1194 int slice_offset = 0; 1195 1196 // Extract the underlying string and the slice offset. 1197 if (StringShape(*subject_tmp).IsCons()) { 1198 subject_tmp = Handle<String>(ConsString::cast(*subject_tmp)->first()); 1199 } else if (StringShape(*subject_tmp).IsSliced()) { 1200 SlicedString* slice = SlicedString::cast(*subject_tmp); 1201 subject_tmp = Handle<String>(slice->parent()); 1202 slice_offset = slice->offset(); 1203 } 1204 1205 // String might have changed. 1206 if (subject_tmp->IsOneByteRepresentation() != is_one_byte) { 1207 // If we changed between an Latin1 and an UC16 string, the specialized 1208 // code cannot be used, and we need to restart regexp matching from 1209 // scratch (including, potentially, compiling a new version of the code). 1210 return RETRY; 1211 } 1212 1213 // Otherwise, the content of the string might have moved. It must still 1214 // be a sequential or external string with the same content. 1215 // Update the start and end pointers in the stack frame to the current 1216 // location (whether it has actually moved or not). 1217 DCHECK(StringShape(*subject_tmp).IsSequential() || 1218 StringShape(*subject_tmp).IsExternal()); 1219 1220 // The original start address of the characters to match. 1221 const byte* start_address = frame_entry<const byte*>(re_frame, kInputStart); 1222 1223 // Find the current start address of the same character at the current string 1224 // position. 1225 int start_index = frame_entry<int>(re_frame, kStartIndex); 1226 const byte* new_address = StringCharacterPosition(*subject_tmp, 1227 start_index + slice_offset); 1228 1229 if (start_address != new_address) { 1230 // If there is a difference, update the object pointer and start and end 1231 // addresses in the RegExp stack frame to match the new value. 1232 const byte* end_address = frame_entry<const byte* >(re_frame, kInputEnd); 1233 int byte_length = static_cast<int>(end_address - start_address); 1234 frame_entry<const String*>(re_frame, kInputString) = *subject; 1235 frame_entry<const byte*>(re_frame, kInputStart) = new_address; 1236 frame_entry<const byte*>(re_frame, kInputEnd) = new_address + byte_length; 1237 } else if (frame_entry<const String*>(re_frame, kInputString) != *subject) { 1238 // Subject string might have been a ConsString that underwent 1239 // short-circuiting during GC. That will not change start_address but 1240 // will change pointer inside the subject handle. 1241 frame_entry<const String*>(re_frame, kInputString) = *subject; 1242 } 1243 1244 return 0; 1245 } 1246 1247 1248 MemOperand RegExpMacroAssemblerMIPS::register_location(int register_index) { 1249 DCHECK(register_index < (1<<30)); 1250 if (num_registers_ <= register_index) { 1251 num_registers_ = register_index + 1; 1252 } 1253 return MemOperand(frame_pointer(), 1254 kRegisterZero - register_index * kPointerSize); 1255 } 1256 1257 1258 void RegExpMacroAssemblerMIPS::CheckPosition(int cp_offset, 1259 Label* on_outside_input) { 1260 BranchOrBacktrack(on_outside_input, 1261 ge, 1262 current_input_offset(), 1263 Operand(-cp_offset * char_size())); 1264 } 1265 1266 1267 void RegExpMacroAssemblerMIPS::BranchOrBacktrack(Label* to, 1268 Condition condition, 1269 Register rs, 1270 const Operand& rt) { 1271 if (condition == al) { // Unconditional. 1272 if (to == NULL) { 1273 Backtrack(); 1274 return; 1275 } 1276 __ jmp(to); 1277 return; 1278 } 1279 if (to == NULL) { 1280 __ Branch(&backtrack_label_, condition, rs, rt); 1281 return; 1282 } 1283 __ Branch(to, condition, rs, rt); 1284 } 1285 1286 1287 void RegExpMacroAssemblerMIPS::SafeCall(Label* to, 1288 Condition cond, 1289 Register rs, 1290 const Operand& rt) { 1291 __ BranchAndLink(to, cond, rs, rt); 1292 } 1293 1294 1295 void RegExpMacroAssemblerMIPS::SafeReturn() { 1296 __ pop(ra); 1297 __ Daddu(t1, ra, Operand(masm_->CodeObject())); 1298 __ Jump(t1); 1299 } 1300 1301 1302 void RegExpMacroAssemblerMIPS::SafeCallTarget(Label* name) { 1303 __ bind(name); 1304 __ Dsubu(ra, ra, Operand(masm_->CodeObject())); 1305 __ push(ra); 1306 } 1307 1308 1309 void RegExpMacroAssemblerMIPS::Push(Register source) { 1310 DCHECK(!source.is(backtrack_stackpointer())); 1311 __ Daddu(backtrack_stackpointer(), 1312 backtrack_stackpointer(), 1313 Operand(-kIntSize)); 1314 __ sw(source, MemOperand(backtrack_stackpointer())); 1315 } 1316 1317 1318 void RegExpMacroAssemblerMIPS::Pop(Register target) { 1319 DCHECK(!target.is(backtrack_stackpointer())); 1320 __ lw(target, MemOperand(backtrack_stackpointer())); 1321 __ Daddu(backtrack_stackpointer(), backtrack_stackpointer(), kIntSize); 1322 } 1323 1324 1325 void RegExpMacroAssemblerMIPS::CheckPreemption() { 1326 // Check for preemption. 1327 ExternalReference stack_limit = 1328 ExternalReference::address_of_stack_limit(masm_->isolate()); 1329 __ li(a0, Operand(stack_limit)); 1330 __ ld(a0, MemOperand(a0)); 1331 SafeCall(&check_preempt_label_, ls, sp, Operand(a0)); 1332 } 1333 1334 1335 void RegExpMacroAssemblerMIPS::CheckStackLimit() { 1336 ExternalReference stack_limit = 1337 ExternalReference::address_of_regexp_stack_limit(masm_->isolate()); 1338 1339 __ li(a0, Operand(stack_limit)); 1340 __ ld(a0, MemOperand(a0)); 1341 SafeCall(&stack_overflow_label_, ls, backtrack_stackpointer(), Operand(a0)); 1342 } 1343 1344 1345 void RegExpMacroAssemblerMIPS::LoadCurrentCharacterUnchecked(int cp_offset, 1346 int characters) { 1347 Register offset = current_input_offset(); 1348 if (cp_offset != 0) { 1349 // t3 is not being used to store the capture start index at this point. 1350 __ Daddu(t3, current_input_offset(), Operand(cp_offset * char_size())); 1351 offset = t3; 1352 } 1353 // We assume that we cannot do unaligned loads on MIPS, so this function 1354 // must only be used to load a single character at a time. 1355 DCHECK(characters == 1); 1356 __ Daddu(t1, end_of_input_address(), Operand(offset)); 1357 if (mode_ == LATIN1) { 1358 __ lbu(current_character(), MemOperand(t1, 0)); 1359 } else { 1360 DCHECK(mode_ == UC16); 1361 __ lhu(current_character(), MemOperand(t1, 0)); 1362 } 1363 } 1364 1365 #undef __ 1366 1367 #endif // V8_INTERPRETED_REGEXP 1368 1369 }} // namespace v8::internal 1370 1371 #endif // V8_TARGET_ARCH_MIPS64 1372
