Lines Matching defs:at
243 // Generate the OSR entry prologue at the first unknown OSR value, or if there
244 // are none, at the OSR entrypoint instruction.
264 instructions_->at(code->instruction_index())->hydrogen_value();
288 __ pop(at);
425 __ li(at, Operand(static_cast<int32_t>(literal->Number())));
426 __ mtc1(at, flt_scratch);
594 LOperand* value = environment->values()->at(i);
630 LOperand* value = environment->values()->at(env_offset + i);
903 DefineDeoptimizationLiteral(inlined_closures->at(i));
933 LOperand* pointer = operands->at(i);
1138 ASSERT(!AreAliased(dividend, scratch, at, no_reg));
1216 __ srl(at, dividend, 31);
1217 __ Addu(result, scratch, Operand(at));
1414 __ li(at, constant);
1415 __ Mul(result, left, at);
1435 __ sra(at, result, 31);
1436 DeoptimizeIf(ne, instr->environment(), scratch, Operand(at));
1448 __ Xor(at, left, right);
1449 __ Branch(&done, ge, at, Operand(zero_reg));
1470 right = Operand(EmitLoadRegister(right_op, at));
1498 // Both 'left' and 'right' are "used at start" (see LCodeGen::DoShift), so
1552 __ And(at, left, Operand(0x80000000));
1553 DeoptimizeIf(ne, instr->environment(), at, Operand(zero_reg));
1592 Register right_reg = EmitLoadRegister(right, at);
1608 overflow); // Reg at also used as scratch.
1616 overflow); // Reg at also used as scratch.
1706 __ SmiTst(object, at);
1707 DeoptimizeIf(eq, instr->environment(), at, Operand(zero_reg));
1772 __ Subu(at, scratch, Operand(encoding == String::ONE_BYTE_ENCODING
1774 __ Check(eq, kUnexpectedStringType, at, Operand(zero_reg));
1830 Register right_reg = EmitLoadRegister(right, at);
1846 overflow); // Reg at also used as scratch.
1854 overflow); // Reg at also used as scratch.
1870 : Operand(EmitLoadRegister(right, at));
1895 // At this point, both left and right are either 0 or -0.
2069 __ LoadRoot(at, Heap::kTrueValueRootIndex);
2070 EmitBranch(instr, eq, reg, Operand(at));
2085 __ lw(at, FieldMemOperand(reg, String::kLengthOffset));
2086 EmitBranch(instr, ne, at, Operand(zero_reg));
2094 __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
2095 __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(at));
2099 __ LoadRoot(at, Heap::kTrueValueRootIndex);
2100 __ Branch(instr->TrueLabel(chunk_), eq, reg, Operand(at));
2101 __ LoadRoot(at, Heap::kFalseValueRootIndex);
2102 __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(at));
2106 __ LoadRoot(at, Heap::kNullValueRootIndex);
2107 __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(at));
2116 __ SmiTst(reg, at);
2117 DeoptimizeIf(eq, instr->environment(), at, Operand(zero_reg));
2125 __ lbu(at, FieldMemOperand(map, Map::kBitFieldOffset));
2126 __ And(at, at, Operand(1 << Map::kIsUndetectable));
2127 __ Branch(instr->FalseLabel(chunk_), ne, at, Operand(zero_reg));
2133 __ lbu(at, FieldMemOperand(map, Map::kInstanceTypeOffset));
2135 ge, at, Operand(FIRST_SPEC_OBJECT_TYPE));
2141 __ lbu(at, FieldMemOperand(map, Map::kInstanceTypeOffset));
2142 __ Branch(¬_string, ge , at, Operand(FIRST_NONSTRING_TYPE));
2143 __ lw(at, FieldMemOperand(reg, String::kLengthOffset));
2144 __ Branch(instr->TrueLabel(chunk_), ne, at, Operand(zero_reg));
2160 __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
2161 __ Branch(¬_heap_number, ne, map, Operand(at));
2295 __ li(at, Operand(factory()->the_hole_value()));
2296 EmitBranch(instr, eq, input_reg, Operand(at));
2318 __ li(at, 0x80000000);
2329 __ mov(at, zero_reg);
2331 EmitBranch(instr, eq, scratch, Operand(at));
2404 Register input_reg = EmitLoadRegister(instr->value(), at);
2405 __ And(at, input_reg, kSmiTagMask);
2406 EmitBranch(instr, eq, at, Operand(zero_reg));
2419 __ And(at, temp, Operand(1 << Map::kIsUndetectable));
2420 EmitBranch(instr, ne, at, Operand(zero_reg));
2511 __ And(at, scratch, Operand(String::kContainsCachedArrayIndexMask));
2512 EmitBranch(instr, eq, at, Operand(zero_reg));
2668 __ li(at, Operand(Handle<Object>(cell)));
2669 __ lw(at, FieldMemOperand(at, PropertyCell::kValueOffset));
2670 __ Branch(&cache_miss, ne, map, Operand(at));
2796 __ sll(at, reg, kPointerSizeLog2);
2797 __ Addu(sp, sp, at);
2810 __ li(at, Operand(Handle<Object>(instr->hydrogen()->cell().handle())));
2811 __ lw(result, FieldMemOperand(at, Cell::kValueOffset));
2813 __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
2814 DeoptimizeIf(eq, instr->environment(), result, Operand(at));
2847 __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
2848 DeoptimizeIf(eq, instr->environment(), payload, Operand(at));
2876 __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
2879 DeoptimizeIf(eq, instr->environment(), result, Operand(at));
2882 __ Branch(&is_not_hole, ne, result, Operand(at));
2900 __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
2903 DeoptimizeIf(eq, instr->environment(), scratch, Operand(at));
2905 __ Branch(&skip_assignment, ne, scratch, Operand(at));
2989 __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
2990 DeoptimizeIf(eq, instr->environment(), result, Operand(at));
3039 __ li(at, Operand(const_length + 1));
3040 __ Subu(result, at, index);
3041 __ sll(at, result, kPointerSizeLog2);
3042 __ Addu(at, arguments, at);
3043 __ lw(result, MemOperand(at));
3051 __ sll(at, result, kPointerSizeLog2);
3052 __ Addu(at, arguments, at);
3053 __ lw(result, MemOperand(at));
3055 __ sll(at, length, kPointerSizeLog2);
3056 __ Addu(at, arguments, at);
3057 __ lw(result, MemOperand(at));
3064 __ sll(at, result, kPointerSizeLog2);
3065 __ Addu(at, arguments, at);
3066 __ lw(result, MemOperand(at));
3177 __ sll(at, key, shift_size);
3178 __ Addu(scratch, scratch, at);
3417 // The arguments are at a one pointer size offset from elements.
3452 Register argument_reg = EmitLoadRegister(argument, at);
3535 // is available to write to at this point.
3542 __ lw(at, FieldMemOperand(a1, JSFunction::kCodeEntryOffset));
3543 __ Call(at);
3578 __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
3579 DeoptimizeIf(ne, instr->environment(), scratch, Operand(at));
3588 __ And(at, exponent, Operand(HeapNumber::kSignMask));
3589 __ Branch(&done, eq, at, Operand(zero_reg));
3596 // Registers were saved at the safepoint, so we can use
3772 at,
3839 DeoptimizeIf(ne, instr->environment(), t3, Operand(at));
4034 // look at the first argument.
4210 __ li(at, Operand(Smi::FromInt(constant_index)));
4212 __ li(at, Operand(constant_index));
4216 at,
4329 __ sll(at, ToRegister(instr->key()), shift_size);
4330 __ Addu(scratch, scratch, at);
4859 __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
4861 __ Branch(&convert, ne, scratch, Operand(at));
4863 DeoptimizeIf(ne, env, scratch, Operand(at));
4868 __ mfc1(at, result_reg.low());
4869 __ Branch(&done, ne, at, Operand(zero_reg));
4877 __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
4878 DeoptimizeIf(ne, env, input_reg, Operand(at));
4911 __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
4912 // This 'at' value and scratch1 map value are used for tests in both clauses
4919 __ Branch(&no_heap_number, ne, scratch1, Operand(at)); // HeapNumber map?
4927 __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
4928 __ Branch(&check_bools, ne, input_reg, Operand(at));
4934 __ LoadRoot(at, Heap::kTrueValueRootIndex);
4935 __ Branch(&check_false, ne, scratch2, Operand(at));
4940 __ LoadRoot(at, Heap::kFalseValueRootIndex);
4941 DeoptimizeIf(ne, instr->environment(), scratch2, Operand(at));
4946 DeoptimizeIf(ne, instr->environment(), scratch1, Operand(at));
5101 __ SmiTst(ToRegister(input), at);
5102 DeoptimizeIf(ne, instr->environment(), at, Operand(zero_reg));
5109 __ SmiTst(ToRegister(input), at);
5110 DeoptimizeIf(eq, instr->environment(), at, Operand(zero_reg));
5143 __ And(at, scratch, mask);
5145 at, Operand(zero_reg));
5161 __ li(at, Operand(Handle<Object>(cell)));
5162 __ lw(at, FieldMemOperand(at, Cell::kValueOffset));
5164 Operand(at));
5182 __ SmiTst(scratch0(), at);
5183 DeoptimizeIf(eq, instr->environment(), at
5221 Handle<Map> map = map_set.at(i).handle();
5224 Handle<Map> map = map_set.at(map_set.size() - 1).handle();
5350 __ Addu(at, result, Operand(scratch));
5351 __ sw(scratch2, MemOperand(at));
5418 __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
5419 __ Branch(&materialized, ne, a1, Operand(at));
5523 __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
5525 cmp2 = Operand(at);
5535 __ lbu(at, FieldMemOperand(input, Map::kBitFieldOffset));
5536 __ And(at, at, 1 << Map::kIsUndetectable);
5537 cmp1 = at;
5549 __ LoadRoot(at, Heap::kTrueValueRootIndex);
5550 __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
5551 __ LoadRoot(at, Heap::kFalseValueRootIndex);
5552 cmp1 = at;
5557 __ LoadRoot(at, Heap::kNullValueRootIndex);
5558 cmp1 = at;
5563 __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
5564 __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
5570 __ lbu(at, FieldMemOperand(input, Map::kBitFieldOffset));
5571 __ And(at, at, 1 << Map::kIsUndetectable);
5572 cmp1 = at;
5588 __ LoadRoot(at, Heap::kNullValueRootIndex);
5589 __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
5599 __ lbu(at, FieldMemOperand(map, Map::kBitFieldOffset));
5600 __ And(at, at, 1 << Map::kIsUndetectable);
5601 cmp1 = at;
5606 cmp1 = at;
5726 __ LoadRoot(at, Heap::kStackLimitRootIndex);
5727 __ Branch(&done, hs, sp, Operand(at));
5743 __ LoadRoot(at, Heap::kStackLimitRootIndex);
5744 __ Branch(deferred_stack_check->entry(), lo, sp, Operand(at));
5775 __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
5776 DeoptimizeIf(eq, instr->environment(), object, Operand(at));
5782 __ And(at, object, kSmiTagMask);
5783 DeoptimizeIf(eq, instr->environment(), at, Operand(zero_reg));
5803 __ LoadRoot(at, Heap::kMetaMapRootIndex);
5804 DeoptimizeIf(ne, instr->environment(), a1, Operand(at));
